2026 இல் நீங்கள் எந்த VLA கொள்கையைப் பயிற்றுவிக்க வேண்டும்?

இன்று ஒரு SO-100 வகுப்பு கையில் ஐந்து கொள்கைகள் பயிற்சி செய்யக்கூடியவை. அவை அனுமானத்தில் 24 காரணி வேறுபடுகின்றன செயல்திறன் தாமதம், 37 அளவுரு எண்ணிக்கை மற்றும் ஒரு ரன் செலவில் 12, மற்றும் நீங்கள் முடிவை அனுப்பலாமா என்பதில் வேறுபடுகின்றன. ஐந்து மாதிரி அட்டைகள் இதை தீர்க்காது: உங்களிடம் உள்ள கேள்விக்கு எதுவும் பதிலளிக்கவில்லை, நான் முதலில் எதை இயக்க வேண்டும்?

கீழே உள்ள ஒவ்வொரு எண்ணும் ஆகஸ்ட் 2026 இல் உள்ள ஆவணங்கள், களஞ்சியங்கள் மற்றும் அட்டைகளில் இருந்து எடுக்கப்பட்டது. தள எண்கள் வருகின்றன இவற்றிலிருந்து AY-Robots கொள்கை பட்டியல்; இரண்டும் வேறுபடும் இடங்களில், இரண்டும் காட்டப்பட்டுள்ளன.

முடிவு அட்டவணை

ஐந்து வேட்பாளர்கள்

ஐந்துமே , கொள்கைகள்: கேமரா பிரேம்கள், கூட்டு நிலைகள் மற்றும், அவற்றில் நான்குக்கும், ஒரு மொழி அறிவுறுத்தல், எதிர்கால கூட்டு இலக்குகளின் ஒரு பகுதிக்கு மேப் செய்யப்பட்டுள்ளது. அவற்றை வேறுபடுத்துவது எவ்வளவு நீங்கள் வருவதற்கு முன் கற்றுக்கொள்ளப்பட்டது.

GR00T N1.7

NVIDIA-வின் தற்போதைய பார்வை-மொழி-செயல் மாதிரி, சுமார் 3 பில்லியன் அளவுருக்களைக் கொண்டது, தோராயமாக 40 மில்லியன் அளவுருக்கள் நுண்ணிய சரிசெய்தலின் போது பயிற்சி பெற்றன. N1.6 இலிருந்து ஏற்பட்ட மாற்றங்களை களஞ்சியம் பட்டியலிடுகிறது: முதுகெலும்பு ஒரு விற்பனையாளர் ஈகிள் மாதிரியிலிருந்து Qwen3-VL இல் உள்ள Cosmos-Reason2-2B ஆக மாற்றப்பட்டது, பரவல் அடுக்குகளின் எண்ணிக்கை 32 இலிருந்து 16 ஆகவும், நிலை மற்றும் செயல் பரிமாணங்கள் 29 இலிருந்து 132 ஆகவும், செயல் எல்லை 16 இலிருந்து 40 ஆகவும் மாற்றப்பட்டுள்ளன.

ஒரு சிறிய கையில் முக்கியமானது சார்பு இறுதி-செயல்பாட்டு செயல்வெளி: N1.7 ஆனது தற்போதைய நிலையிலிருந்து ஏற்படும் மாற்றங்களை கணிக்கிறது, இது 20K மணிநேர ஈகோஸ்கேல் மனித வீடியோவை ஒரு ரோபோ கொள்கையாக மாற்ற அனுமதிக்கிறது. விவரக்குறிப்புகள் N1.7 பக்கத்தில், செயல்முறை SO-100 வழிகாட்டியில் N1.7.

GR00T N1.5

அதே 3 B அளவு, ஈகிள் 2 பேக்போன், சிக்லிப்2 மற்றும் T5, ஃப்ளோ-மேட்சிங் டிஐடி ஹெட். இது ஏற்கனவே உங்களிடம் உள்ள ஒரு ஐ நீட்டிக்க உதவுகிறது. இரண்டு விஷயங்கள் இதை ஒரு மோசமான இயல்புநிலையாக ஆக்குகின்றன: எடைகள் NVIDIA's one-way non-commercial licence, and current LeRobot releases removed N1.5 support. See .

Pi0.5

Physical Intelligence's VLA, கொள்கை வகை pi05. இந்த ஆய்வுக் கட்டுரை PaliGemma இலிருந்து தொடங்கப்பட்ட 2 B VLM மற்றும் 300 M செயல் நிபுணரைக் கொடுக்கிறது, இது ரோபோவை 50 Hz இல் இயக்குகிறது; LeRobot's pi05 config defaults to a 50-step chunk, one second at that rate. The selling point is unseen places: உண்மையான வீடுகளில் சுமார் 400 மணிநேர மொபைல் கையாளுதல், மற்றும் 3, 12, 22, 53, 82 மற்றும் 104 இடங்களுக்கு மேல் ஒரு ஸ்கேலிங் ஆய்வு, அங்கு 104-இட மாதிரி, சோதனை வீடுகளிலேயே பயிற்சி பெற்ற ஒரு கட்டுப்பாட்டுடன் பொருந்தியது.

ஒரு வரம்பு, குறிப்பிடப்பட்டுள்ளது lerobot/pi05_base கார்டில்: போர்ட் பாய்வு-பொருந்தும் செயல்பாட்டுத் தலையை மட்டுமே கொண்டு செல்கிறது. துணைப்பணி கணிப்பு, செயல்பாட்டு டோக்கனைசேஷன் மற்றும் RL ஆகியவை அப்ஸ்ட்ரீமில் வெளியிடப்படவில்லை, மேலும் openpi அதன் சொந்த களஞ்சியத்தைப் பற்றியும் அதையே கூறுகிறது. Pi0.5 பக்கம் மற்றும் SO-100 வழிகாட்டியில் Pi0.5 மீதமுள்ளவற்றை கொண்டுள்ளது.

SmolVLA

450 M அளவுருக்கள், செயல்பாட்டு நிபுணரில் சுமார் 100 M, SmolVLM-2 இல் VLM உறைந்துபோய், அதன் முதல் 16 மொழி-மாடல் அடுக்குகளை மட்டுமே பயன்படுத்தி. முன் பயிற்சி சமூகத் தரவுகளாகும்: 481 தரவுத்தொகுப்புகள், 10.6 M பிரேம்கள், நீங்கள் பயன்படுத்தும் அதே மலிவான கைகளிலிருந்து. இங்குள்ள ஒரே VLA, ஒரு 24 GB கார்டில் பொருந்துகிறது, மேலும் ஒரே 30 எபிசோட் தளம். பார்க்கவும் SmolVLA பக்கம்.

ACT

இது ஒரு அடிப்படை மாதிரி அல்ல. ALOHA இலிருந்து வரும் Action Chunking Transformer ஆனது சுமார் 80 M அளவுருக்களைக் கொண்டது, இது ஒவ்வொரு பணிக்கும் புதிதாகப் பயிற்றுவிக்கப்பட்டது, 50 Hz இல் 50 செயல்விளக்கங்கள் மூலம். இந்த ஆய்வுக் கட்டுரை சுமார் பத்து நிமிட செயல்விளக்கங்களிலிருந்து ஆறு உண்மையான இருகைப் பணிகளைப் பற்றி அறிக்கை செய்கிறது, இது எடுத்துக்காட்டுகளில் 80 முதல் 90 சதவீதம் வரை வெற்றியைப் பெற்றது. இதன் யோசனை, செயல் துண்டாக்கம், இந்த பக்கத்தில் உள்ள ஒவ்வொரு மாதிரியிலும் உள்ளது, மேலும் அதன் நீக்கம் இன்னும் விளைவை சிறப்பாக அளவிடுகிறது: தற்காலிக ஒருங்கிணைப்பு அணைக்கப்பட்ட இரண்டு உருவகப்படுத்தப்பட்ட பணிகளில், k=1 இல் 1 சதவீதத்திலிருந்து k=100 இல் 44 சதவீதமாக வெற்றி அதிகரிக்கிறது. ACT பக்கம் மீதமுள்ள தகவல்களைக் கொண்டுள்ளது.

தரவு அளவுகோல்கள் உண்மையில் என்ன சொல்கின்றன

LIBERO என்பது இந்த ஐந்தில் மூன்று மாதிரிகள் அறிக்கை செய்யும் ஒரு தரவு அளவுகோல்: உருவகப்படுத்தப்பட்ட Franka Panda இல் மொழி-நிபந்தனைக்குட்பட்ட பணிகள், கீழே உள்ள நான்கு தொகுப்புகளாகப் பிரிக்கப்பட்டு, ஒவ்வொன்றிலும் பத்து பணிகள் உள்ளன. NVIDIA ஒவ்வொரு தொகுப்பிற்கும் 200 சோதனைகளை நடத்தியது.

SimplerEnv பரவலைக் காட்டுகிறது, ஆனால் LIBERO காட்டவில்லை. NVIDIA ஆனது N1.7 ஐ N1.6 உடன் ஒப்பிடுகிறது, இது ஒரு தலைமுறை வேறுபாடு.

பிரிட்ஜ் வரிசை பயனுள்ளது: சராசரியாக 5.7 புள்ளிகள் பெற்றது, அதே நேரத்தில் put_eggplant_in_basket 36 புள்ளிகளை இழந்தது மற்றும் put_eggplant_in_sink 33 இலிருந்து 2 ஆகக் குறைந்தது. ஒரு புதிய தலைமுறை விநியோகத்தை உயர்த்துவதற்குப் பதிலாக நகர்த்துகிறது, எனவே உங்கள் பணி N1.7 பின்னடைவு ஏற்பட்ட இடத்தில் இருந்தால், சராசரி எதுவும் சொல்லாது.

ஐந்தில், SmolVLA ஆய்வுக் கட்டுரை மட்டுமே SO-100 வகுப்பு கையைப் பற்றி அறிக்கை செய்கிறது: மூன்று பணிகளில் SmolVLA க்கு 78.3 சதவீதமும், Pi0 க்கு 61.7 சதவீதமும், இரண்டும் பல பணிகளுக்கானவை, ஒற்றைப் பணிக்காகப் பயிற்சி பெற்ற ACT க்கு 48.3 சதவீதத்திற்கு எதிராக, இது ஒப்பிடக்கூடியது அல்ல. தெளிவான ஜோடி SO-101 பிக்-அண்ட்-பிளேஸில் இரண்டும் ஒற்றைப் பணிக்கானவை: விநியோகத்தில் 70 க்கு எதிராக 90, அதற்கு வெளியே 40 க்கு எதிராக 50. ஒப்பிடுக ACT மற்றும் SmolVLA மற்றும் Pi0.5 மற்றும் SmolVLA, அல்லது உலாவுக அரங்கம்.

தாமதம் மற்றும் செலவு வரிசைப்படுத்தலைத் தீர்மானிக்கின்றன

இன்ஃபரன்ஸ் லேட்டன்சி என்பது மக்கள் கடைசியாகக் கண்டுபிடிக்கும் மற்றும் முதலில் வருந்தும் ஒரு வரம்பு. ஒரு பெஞ்ச்மார்க்கில் ஐந்து புள்ளிகள் சிறப்பாக இருக்கும் ஒரு கொள்கை, ஆனால் ஒரு செயல் படிக்கு அரை வினாடி தாமதம் உங்கள் மேசையில் மோசமாகத் தோன்றும்: தொடர்பு இயக்கவியல் காத்திருக்காது.

ஒரு எச்சரிக்கை: GR00T எண்ணிக்கை NVIDIA இன் கார்டுடன் ஒத்துப்போகவில்லை, இது 4 டி-நாய்ஸிங் படிகள் மற்றும் ஒரு கேமராவை H100 இல் ஈகர் பயன்முறையில் 85.8 ms, torch.compile உடன் 48.6 ms, முழு TensorRT வழியாக 27.9 ms என அளவிடுகிறது. இங்குள்ள 152 ms என்பது சேவை மேலதிகச் செலவு மற்றும் ஒன்றுக்கு மேற்பட்ட கேமராக்களுடன் கூடிய முழு-ஸ்டாக் எண்ணிக்கை, இது ஒரு ஃபார்வர்ட் பாஸ் அல்ல.

மாதிரியை மாற்றாமல் நேரத்தை வாங்குவதற்கான ஒரு வழி: SmolVLA கட்டுரை ஒத்திசைவான செயல்பாட்டை அளவிடுகிறது, அங்கு கொள்கை அடுத்ததை கணிப்பதற்கு முன் ஒரு பகுதியை முடிக்கிறது, ஒத்திசைவற்ற செயல்பாட்டிற்கு எதிராக, அங்கு கணிப்பு செயல்பாட்டுடன் ஒன்றுடன் ஒன்று இணைகிறது. வெற்றி ஒத்திருக்கிறது, 78.3 க்கு எதிராக 73.3, ஆனால் அதே பிக்-அண்ட்-பிளேஸ் 13.75 க்கு பதிலாக 9.7 வினாடிகள் எடுக்கிறது, மேலும் ஒரு நிலையான சாளரத்தில் ரோபோ 9 க்கு பதிலாக 19 சுழற்சிகளை நிர்வகிக்கிறது.

உரிமங்கள், யாரும் சரிபார்க்காததால் சரிபார்க்கப்பட்டது

Pi0.5 வரிசைக்கு கவனம் தேவை. LeRobot pi05 ஆவணங்கள் Apache 2.0 ஐ openpi உடன் இணக்கமாகக் குறிப்பிடுகின்றன, அதே நேரத்தில் Hub அட்டை lerobot/pi05_base கொண்டுள்ளது license: gemma. இரண்டும் செயல்பாட்டில் உள்ளன. GR00T N1.7 ஒரு மென்மையான பதிப்பைக் கொண்டுள்ளது: Isaac-GR00T README ஆனது N1.7 ஆனது Apache 2.0 இன் கீழ் முழுமையாக வணிக ரீதியாக உரிமம் பெறக்கூடியது என்று குறிப்பிடுகிறது, அதே நேரத்தில் அதன் சொந்த உரிமப் பிரிவு மற்றும் மாதிரி அட்டை குறியீட்டை மட்டும் Apache 2.0 இன் கீழும், எடைகளை NVIDIA திறந்த மாதிரி உரிமத்தின் கீழும் வைக்கின்றன.

நீங்கள் உண்மையில் இயக்கும் இயல்புநிலைகள்

ஒவ்வொரு பயிற்சியாளர் படிவமும் ஒரு இயல்புநிலையை அனுப்புகிறது, மேலும் அவை தன்னிச்சையானவை அல்ல. ACT இன் இயல்புநிலைகள் LeRobot இன் சொந்தமானவை: தொகுதி 8, lr 1e-5, 100000 பயிற்சி படிகள், chunk size 100, matching ACTConfig upstream and k=100 from the ACT paper. கீழே உள்ள ஒரு நெடுவரிசை ஒரு பொறி.

மாதிரித் தேர்வை விட முக்கியமான கட்டுப்பாடு

இது செயல் துண்டு. நீண்ட துண்டுகள் மென்மையான இயக்கத்தையும் குறைவான கூட்டுப் பிழைகளையும் தருகின்றன, ஆனால் தொகுதி செயல்படுத்தப்படும்போது கொள்கை உறுதிப்படுத்தப்படுகிறது, எனவே நகரும் எதற்கும் தாமதமாக எதிர்வினையாற்றுகிறது: ஒரு நிலையான கனசதுரத்தில் நம்பிக்கையுடன், உருளும் ஒன்றில் நம்பிக்கையற்றது. அது மிகைப்படுத்தினால், செயல்படுத்தப்பட்ட பகுதியை சுருக்குவது மறுபயிற்சியை விட சிறந்தது மற்றும் இலவசம். குறுகியதாக நிற்கும் ஒரு மூட்டு ஒரு வேறுபட்ட பிரச்சனை; பார்க்கவும் .

• ACT: ACTConfig இயல்பாக chunk_size 100 மற்றும் n_action_steps 100 ஆக இருக்கும். தற்காலிக ஒருங்கிணைப்பு முடக்கப்பட்டுள்ளது மற்றும் n_action_steps 1 தேவைப்படுகிறது.
• GR00T N1.7: உள் எல்லை 16 இலிருந்து 40 ஆக உயர்ந்தது, ஆனாலும் LeRobot இன் SO-101 எடுத்துக்காட்டு இன்னும் --policy.chunk_size=16 --policy.n_action_steps=16 ஐ இயக்குகிறது. ரோல்அவுட் கொடி --execution-horizon என மறுபெயரிடப்பட்டது.
• Pi0.5: ஒரு 50-படி துண்டு, இதில் LeRobot இன் LIBERO செய்முறை --policy.n_action_steps=10 வழியாக 10 ஐ செயல்படுத்துகிறது; நீங்கள் கொடியை நீக்கினால் --policy.pretrained_path உடன் அது 50 ஆக திரும்பும்.
• SmolVLA: 50-செயல் துண்டுகள், இரண்டு கட்டுப்பாடுகளும் வெளிப்படுத்தப்பட்டுள்ளன.

ஒரு மதிய வேளையில் ஐந்தையும் எப்படி சோதிப்பது

மலிவான பதில் மேலும் படிப்பது அல்ல. சுமார் 15 USD செலவழித்து, கை உங்களுக்குச் சொல்லட்டும்: ஒருமுறை பதிவுசெய்து, முதலில் மலிவான மாதிரியைப் பயிற்றுவிக்கவும், தரவு சரியாக இருப்பதாக நிரூபிக்கப்பட்டவுடன் அதிகரிக்கவும். அமைப்பு அளவை விட சிறந்தது, இதன் நோக்கம் மற்றும் .

1. 1
   50 எபிசோடுகளை ஒருமுறை பதிவு செய்யவும்

   GR00T, Pi0.5 மற்றும் ACT-க்கு 50, SmolVLA-க்கு 30 என்ற எண்ணிக்கையில் தரவுகளைப் பதிவு செய்யவும். ஒவ்வொரு மாறுபாட்டையும் பரவலாகப் பதிவு செய்யாமல் மீண்டும் மீண்டும் செய்யவும்: 50 எபிசோடுகள் 5 கியூப் நிலைகளில் பயிற்சி செய்யப்பட்டன, 25 எபிசோடுகள் பயிற்சி செய்யப்படவில்லை. உங்கள் முதல் தரவுத்தொகுப்பைப் பதிவு செய்யவும்.

   bash

   lerobot-record \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM1 \
     --robot.id=my_follower_arm \
     --teleop.type=so100_leader \
     --teleop.port=/dev/ttyACM0 \
     --teleop.id=my_leader_arm \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --dataset.num_episodes=50 \
     --dataset.single_task="Put the lego brick into the box"

2. 2
   ACT-ஐ முதலில் பயிற்சி செய்யவும், ஏனெனில் அது உங்களை ஏமாற்றாது

   முன்பயிற்சி செய்யப்பட்ட எடைகள் இல்லை, எனவே இது பணியைச் செய்தால், உங்கள் தரவுத்தொகுப்பில் அந்தப் பணி உள்ளது. ACT செயலற்றுப் போனால், தரவைச் சரிசெய்யவும். 1 முதல் 3 USD, 24 GB கார்டில் 2 முதல் 5 மணிநேரம்.

   bash

   lerobot-train \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --policy.type=act \
     --policy.device=cuda \
     --batch_size=8 \
     --steps=100000 \
     --seed=1000 \
     --output_dir=outputs/train/act_pickplace \
     --job_name=act_pickplace

3. 3
   மாற்றப்படாத அதே தரவுத்தொகுப்பில் SmolVLA-வை இயக்கவும்

   அதே தரவு, அதே கை, 80 M அளவுருக்களுக்குப் பதிலாக 450 M அளவுருக்கள், மேலும் மொழி சார்ந்த நிபந்தனைகள். LeRobot ஒரு A100-ல் சுமார் 4 மணிநேரத்தில் 20K படிநிலைப் பயிற்சியை நிறைவு செய்கிறது. முன்பயிற்சி ஏதேனும் பயனுள்ளதா என்பதை இது உங்களுக்குத் தெரிவிக்கும்.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --batch_size=64 \
     --steps=20000 \
     --policy.device=cuda \
     --output_dir=outputs/train/smolvla_pickplace \
     --job_name=smolvla_pickplace

4. 4
   GR00T-ஐப் பயன்படுத்துவதற்கு முன் v2.1-க்கு மாற்றவும்

   GR00T ஆனது LeRobot v2 வடிவத்தின் ஒரு வகையை, மேலும் இணைக்கப்பட்ட நிலை மற்றும் செயல் வரிசைகள் பெயரிடப்பட்ட புலங்களாக எவ்வாறு பிரிக்கப்படுகின்றன என்பதைக் காட்டும் கூடுதல் meta/modality.json கோப்பையும் படிக்கிறது. ஒரு v3.0 தரவுத்தொகுப்பு அந்த லோடரை செயலிழக்கச் செய்கிறது, ஏனெனில் v3.0 பல எபிசோடுகளைப் பகிரப்பட்ட கோப்புகளில் தொகுக்கிறது, அதேசமயம் v2 ஒரு எபிசோடுக்கு ஒரு கோப்பை எழுதியது. Isaac-GR00T ஆனது scripts/lerobot_conversion/convert_v3_to_v2.py என்ற டவுன்கிரேட் உதவியாளரை வழங்குகிறது; v3 நிராகரிப்புப் பக்கம் ஒரு விரைவான வழி.

   text

   # GR00T expects this layout, not the v3.0 file-based one
   my_dataset/
     meta/
       info.json
       episodes.jsonl      # episode index and lengths
       tasks.jsonl         # language task descriptions
       modality.json       # GR00T-specific: state/action/video key mapping
     data/chunk-000/       # parquet, state and action per timestep
     videos/chunk-000/     # one mp4 per episode

5. 5
   முதல் இரண்டு முறைகள் திருப்திகரமாக இல்லாவிட்டால் மட்டுமே GR00T N1.7-க்கு மேம்படுத்தவும்

   இங்கு காட்டப்பட்டுள்ள NVIDIA-வின் CLI மூலமாகவோ அல்லது LeRobot-ன் groot கொள்கை வகை மூலமாகவோ. NVIDIA ஆனது ஃபைன்-ட்யூனிங்கிற்கு 40 GB அல்லது அதற்கு மேற்பட்ட VRAM-ஐயும், இன்ஃபரன்ஸிற்கு 16 GB-ஐயும் பரிந்துரைக்கிறது. OOM ஏற்பட்டால், OOM பக்கத்தைப் பார்க்கவும்.

   bash

   CUDA_VISIBLE_DEVICES=0 uv run python \
     gr00t/experiment/launch_finetune.py \
     --base-model-path nvidia/GR00T-N1.7-3B \
     --dataset-path demo_data/cube_to_bowl_5 \
     --embodiment-tag NEW_EMBODIMENT \
     --modality-config-path examples/SO100/so100_config.py \
     --num-gpus 1 \
     --output-dir /tmp/test_finetune \
     --max-steps 2000 \
     --global-batch-size 32 \
     --dataloader-num-workers 4

அந்த ஸ்கிரீனிங் பாஸை இயக்க இரண்டு வழிகள்

# 1. LeRobot: ACT, SmolVLA, Pi0.5 and GR00T N1.7 via --policy.type=groot
pip install "lerobot[smolvla]"
pip install "lerobot[pi]"
pip install "lerobot[groot]"

# 2. GR00T reference implementation and benchmark examples
git clone https://github.com/NVIDIA/Isaac-GR00T

# 3. Physical Intelligence reference implementation
git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi

அடிப்படை மாதிரி அல்லது புதிதாக

உண்மையான சிக்கல் எந்த 3B மாடலைத் தேர்ந்தெடுப்பது என்பதல்ல. ஒரு முன்-பயிற்சி பெற்ற VLA-வை பயன்படுத்த வேண்டுமா என்பதே. ACT ஆனது, 80 மில்லியன் அளவுருக்களுடன், எந்த முன்-பயிற்சியும் இல்லாமல், ஒவ்வொரு பணிக்கும் சுமார் பத்து நிமிட செயல்விளக்கங்களிலிருந்து ஆறு உண்மையான இருகைப் பணிகளைக் கற்றுக்கொண்டது என்பதைக் கருத்தில் கொள்ளும்போது.

பழைய ரன்னை மீண்டும் உருவாக்குதல்

2025 செக்பாயிண்டைப் பின்தொடர்வது உங்களுக்கான மாடல் தேர்வை எளிதாக்குகிறது மற்றும் சிக்கலை பதிப்பு குறியீடாக மாற்றுகிறது: தற்போதைய LeRobot N1.5 ஐ நிராகரிக்கிறது, எனவே நீங்கள் குறியிடுகிறீர்கள் lerobot==0.5.1. எந்த விதை புலமும் இல்லாமல் மற்றும் ரன்களுக்கு இடையில் 5 முதல் 6 சதவீதம் மாறுபாட்டுடன், மறுஉருவாக்கம் தோராயமானது. மற்றும் தளப் பக்கத்தைக் கொண்டுள்ளன.

இரண்டாகக் குறைந்ததா? ACT எதிராக GR00T N1.7 மற்றும் GR00T N1.7 எதிராக SmolVLA. மூல வரிசைகள் அரங்கம் உள்ளீடுகளில் உள்ளன: GR00T N1.7, Pi0.5, SmolVLA மற்றும் ACT.

இந்த தளம் உங்களுக்கு எங்கு உதவாது

• இது தொலைநிலை ஊகத்தை (remote inference) விரைவுபடுத்த முடியாது. 20 முதல் 485 மில்லி விநாடிகள் சுழற்சி மாதிரிக்கு உரியது; இணையப் பயணங்கள் அதை மேலும் அதிகரிக்கும்.
• இது GR00T அல்லது Pi0.5 ஐ உங்கள் சொந்த வன்பொருளில் நுண்-சரிசெய்ய (fine-tune) முடியாது. இங்கு இரண்டும் கிளவுட்-மட்டுமே; SmolVLA மற்றும் ACT மட்டுமே உள்ளூரில் இயங்கும்.
• இது ஒரு தரவுத்தொகுப்பை (dataset) சரிசெய்ய முடியாது. இழப்பு குறைகிறது ஆனால் கொள்கை எதுவும் செய்யவில்லை என்பது ஒரு தரவுச் சிக்கல், ஒரு அமைப்பில் மட்டுமே செயல்படும் ஒரு கொள்கை என்பது ஒரு கவரேஜ் சிக்கல்.
• இது GR00T இயக்கங்களை மீண்டும் உருவாக்கக்கூடியதாக (reproducible) மாற்ற முடியாது: மேல்நிலை உள்ளமைவில் (upstream config) 'seed' புலம் இல்லை.

ஒன்றைத் தேர்ந்தெடுத்து முன்னேறுதல்

ஒரு இயல்புநிலை: 50 எபிசோட்களைப் பதிவுசெய்து, தரவுத்தொகுப்பை நிரூபிக்க ACT ஐ 1 முதல் 3 USD க்குப் பயிற்சி அளித்து, பின்னர் SmolVLA ஐ அதே தரவில் பயன்படுத்தவும். மொத்தமாக 6 USD க்கும் குறைவாக, அவை முக்கியமான கேள்விக்கு பதிலளிக்கின்றன: இங்கே முன் பயிற்சி உதவுகிறதா, அல்லது தடை தரவுதானா. தொடர்பு நிறைந்த பல-படி பணிகளுக்கு GR00T N1.7 க்கு மேம்படுத்தவும், காட்சி மாறும்போது Pi0.5 க்கு, காட்சி மாறும்போது.

தள வழிகாட்டி: உங்கள் முதல் கொள்கையைப் பயிற்றுவிக்கவும், பின்னர் உங்கள் முதல் கொள்கையை இயக்கவும். பயிற்சி ஆவணங்கள் மற்றும் தரவுத்தொகுப்பு ஆவணங்கள் படிவம் மற்றும் வடிவமைப்பை உள்ளடக்கியது; SO-100 பக்கம் மற்றும் முழுமையான SO-100 வழிகாட்டி உருவாக்கம் மற்றும் அளவீட்டை உள்ளடக்கியது. பின்னணி: VLA கண்ணோட்டம் மற்றும் Pi0 ஃப்ளோ-மேட்சிங் கட்டுரை. உங்கள் வெற்றி விகிதத்தை அதிகரிக்கும் ஒன்று தரவு தர வழிகாட்டி.