आपको 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, फ्लो-मैचिंग DiT हेड। यह आपके पास पहले से मौजूद एक को विस्तारित करने के लिए मौजूद है। दो बातें इसे एक खराब डिफ़ॉल्ट बनाती हैं: इसके वज़न में NVIDIA का एकतरफा गैर-व्यावसायिक लाइसेंस है, और वर्तमान LeRobot रिलीज़ ने N1.5 समर्थन हटा दिया है। देखें .

Pi0.5

फिजिकल इंटेलिजेंस का VLA, पॉलिसी प्रकार pi05। यह पेपर पालिगेमा से इनिशियलाइज़्ड 2 B VLM और 300 M एक्शन एक्सपर्ट देता है, जो रोबोट को 50 Hz पर चलाता है; LeRobot का pi05 कॉन्फ़िग डिफ़ॉल्ट रूप से 50-स्टेप चंक पर सेट होता है, उस दर पर एक सेकंड। इसका मुख्य विक्रय बिंदु अनदेखी जगहें हैं: वास्तविक घरों में लगभग 400 घंटे का मोबाइल मैनिपुलेशन, और 3, 12, 22, 53, 82 और 104 स्थानों पर एक स्केलिंग अध्ययन, जहाँ 104-स्थान मॉडल ने स्वयं परीक्षण घरों पर प्रशिक्षित नियंत्रण से मेल खाया।

एक सीमा, जो इस पर बताई गई है lerobot/pi05_base कार्ड पर: पोर्ट केवल फ्लो-मैचिंग एक्शन हेड को वहन करता है। सबटास्क प्रेडिक्शन, एक्शन टोकनाइजेशन और आरएल को अपस्ट्रीम जारी नहीं किया गया था, और ओपनपी अपने रिपॉजिटरी के बारे में भी यही कहता है। 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 का एक्शन चंकिंग ट्रांसफार्मर लगभग 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 से करता है, जो एक पीढ़ीगत डेल्टा

ब्रिज रो उपयोगी है: put_eggplant_in_basket में औसतन 5.7 अंक प्राप्त हुए, 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 दस्तावेज़ openpi के अनुरूप Apache 2.0 बताता है, जबकि हब कार्ड के लिए lerobot/pi05_base में है license: gemma। दोनों सक्रिय हैं। GR00T N1.7 का एक हल्का संस्करण है: Isaac-GR00T README में यह उल्लेख किया गया है कि N1.7 Apache 2.0 के तहत पूरी तरह से व्यावसायिक रूप से लाइसेंस योग्य है, जबकि इसका अपना लाइसेंस अनुभाग और मॉडल कार्ड केवल कोड को Apache 2.0 के तहत और वजन को NVIDIA ओपन मॉडल लाइसेंस के तहत रखते हैं।

वे डिफ़ॉल्ट जिन्हें आप वास्तव में चलाएंगे

प्रत्येक ट्रेनर फॉर्म एक डिफ़ॉल्ट के साथ आता है, और वे मनमाने नहीं होते हैं। ACT के अपने हैं: बैच 8, lr 1e-5, 100000 प्रशिक्षण चरण, चंक आकार 100, ACTConfig अपस्ट्रीम और k=100 from the ACT paper. नीचे एक कॉलम एक जाल है।

मॉडल के चुनाव से अधिक महत्वपूर्ण नॉब

यह एक्शन चंक है। लंबे चंक से गति अधिक सहज होती है और त्रुटियाँ कम जमा होती हैं, लेकिन ब्लॉक के निष्पादित होने के दौरान नीति प्रतिबद्ध होती है, इसलिए यह हिलने वाली किसी भी चीज़ पर देर से प्रतिक्रिया करती है: एक स्थिर क्यूब पर आत्मविश्वासपूर्ण, एक लुढ़कते हुए पर निराशाजनक। यदि यह ओवरशूट करता है, तो निष्पादित हिस्से को छोटा करना रिट्रेनिंग से बेहतर है और यह मुफ्त है। एक जोड़ जो बीच में रुक जाता है वह एक अलग समस्या है; देखें ।

• ACT: ACTConfig defaults to chunk_size 100 and n_action_steps 100. टेम्पोरल एन्सेम्बलिंग बंद है और इसके लिए आवश्यक है n_action_steps 1.
• GR00T N1.7: आंतरिक क्षितिज 16 से 40 हो गया, फिर भी LeRobot's SO-101 उदाहरण अभी भी चलता है --policy.chunk_size=16 --policy.n_action_steps=16. रोलआउट फ़्लैग का नाम बदलकर --execution-horizon कर दिया गया था।
• Pi0.5: एक 50-स्टेप चंक, जिसमें से LeRobot's LIBERO रेसिपी 10 को निष्पादित करती है --policy.n_action_steps=10; --policy.pretrained_path के साथ यदि आप फ़्लैग छोड़ देते हैं तो यह 50 पर वापस आ जाता है।
• SmolVLA: 50-एक्शन चंक, दोनों नॉब उजागर।

एक दोपहर में सभी पाँचों को कैसे स्क्रीन करें

सबसे सस्ता जवाब अधिक पढ़ना नहीं है। लगभग 15 USD खर्च करें और रोबोटिक आर्म को आपको बताने दें: एक बार रिकॉर्ड करें, पहले सस्ते मॉडल को प्रशिक्षित करें, एक बार जब यह डेटा को सही साबित कर दे तो आगे बढ़ें। संरचना मात्रा से बेहतर है, जिसका उद्देश्य है और ।

1. 1
   एक बार में 50 एपिसोड रिकॉर्ड करें

   GR00T, Pi0.5 और ACT के लिए पचास, और SmolVLA के तीस के लिए रास्ता साफ करता है। प्रत्येक भिन्नता को पतला फैलाने के बजाय दोहराएं: 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 फ्लैटलाइन हो जाता है, तो डेटा को ठीक करें। 24 GB कार्ड पर 1 से 3 USD, 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

फाउंडेशन मॉडल या स्क्रैच से

असली दुविधा यह नहीं है कि कौन सा 3 B मॉडल चुनना है। यह है कि क्या एक पूर्व-प्रशिक्षित VLA का उपयोग बिल्कुल करना है, यह देखते हुए कि ACT ने प्रत्येक लगभग दस मिनट के प्रदर्शन से छह वास्तविक द्वि-मैनुअल कार्य सीखे, जिसमें 80 M पैरामीटर थे और कुछ भी पूर्व-प्रशिक्षित नहीं था।

एक पुराने रन को पुनरुत्पादित करने का मामला

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.

यह प्लेटफ़ॉर्म आपकी कहाँ मदद नहीं करता

• यह रिमोट इन्फेरेंस को तेज़ नहीं कर सकता। 20 से 485 मिलीसेकंड का लूप मॉडल का है; इंटरनेट राउंड ट्रिप इसमें और समय जोड़ते हैं।
• यह आपके अपने हार्डवेयर पर GR00T या Pi0.5 को फाइन-ट्यून नहीं कर सकता। यहां दोनों केवल क्लाउड-आधारित हैं; केवल SmolVLA और ACT स्थानीय रूप से चलते हैं।
• यह डेटासेट को ठीक नहीं कर सकता। लॉस कम होता है लेकिन पॉलिसी कुछ नहीं करती एक डेटा समस्या है, एक पॉलिसी जो केवल एक सेटअप में काम करती है एक कवरेज समस्या है।
• यह GR00T रन को रिप्रोड्यूसिबल नहीं बना सकता: क्योंकि अपस्ट्रीम कॉन्फ़िग में कोई सीड फ़ील्ड नहीं है।

एक चुनना और आगे बढ़ना

एक डिफ़ॉल्ट: 50 एपिसोड रिकॉर्ड करें, डेटासेट को प्रमाणित करने के लिए ACT को 1 से 3 USD में प्रशिक्षित करें, फिर SmolVLA को उसी डेटा पर। कुल मिलाकर 6 USD से कम में, और वे उस महत्वपूर्ण प्रश्न का उत्तर देते हैं: क्या यहाँ प्रीट्रेनिंग मदद करती है, या क्या बाधा डेटा है। संपर्क-समृद्ध बहु-चरणीय कार्यों के लिए GR00T N1.7 पर जाएँ, जब दृश्य बदलता है तो Pi0.5 पर।

प्लेटफ़ॉर्म वॉकथ्रू: अपनी पहली नीति को प्रशिक्षित करें, फिर अपनी पहली नीति चलाएँ। प्रशिक्षण दस्तावेज़ और डेटासेट दस्तावेज़ फॉर्म और प्रारूप को कवर करते हैं; SO-100 पृष्ठ और संपूर्ण SO-100 गाइड निर्माण और अंशांकन को कवर करते हैं। पृष्ठभूमि: VLA अवलोकन और Pi0 फ्लो-मैचिंग लेख। जो आपकी सफलता दर को बढ़ाएगा वह है डेटा गुणवत्ता गाइड।