2026 मध्ये तुम्ही कोणती VLA पॉलिसी प्रशिक्षित करावी?

आज SO-100 श्रेणीच्या आर्मवर पाच पॉलिसी प्रशिक्षित करता येतात. त्यांची इन्फरन्स लेटन्सीमध्ये 24 च्या पटीत, पॅरामीटर संख्येत 37 च्या पटीत आणि एका रनच्या खर्चात 12 च्या पटीत फरक आहे, तसेच तुम्ही परिणाम पाठवू शकता की नाही यातही फरक आहे. पाच मॉडेल कार्ड्स हे स्पष्ट करणार नाहीत: तुमच्या प्रश्नाचे उत्तर कोणीही देत नाही, मी आधी कोणते चालवू?

खालील प्रत्येक संख्या ऑगस्ट 2026 मध्ये पेपर्स, रेपो आणि कार्ड्समधून वाचली गेली आहे. प्लॅटफॉर्म संख्या येथून येतात AY-Robots policy catalog; जिथे दोन्ही असहमत आहेत, तिथे दोन्ही दाखवले आहेत.

निर्णय सारणी

पाच उमेदवार

सर्व पाच आहेत धोरणे: कॅमेरा फ्रेम्स, जॉइंट पोझिशन्स आणि, त्यापैकी चारसाठी, एक भाषा सूचना, भविष्यातील जॉइंट लक्ष्यांच्या एका भागाशी जोडलेली. त्यांना काय वेगळे करते ते म्हणजे तुम्ही येण्यापूर्वी किती शिकले गेले होते.

GR00T N1.7

NVIDIA चे सध्याचे व्हिजन-लँग्वेज-ॲक्शन मॉडेल, सुमारे 3 अब्ज पॅरामीटर्स, अंदाजे 40 दशलक्ष फाइन-ट्यूनिंग दरम्यान प्रशिक्षण दिले गेले. रेपॉजिटरीमध्ये N1.6 पासूनचे बदल सूचीबद्ध आहेत: बॅकबोन एका वेंडर्ड ईगल मॉडेलवरून Cosmos-Reason2-2B वरील Qwen3-VL मध्ये बदलले, डिफ्यूजन लेयर्स 32 वरून 16, स्टेट आणि ॲक्शन डायमेन्शन्स 29 वरून 132, ॲक्शन होरायझन 16 वरून 40.

लहान आर्मवर महत्त्वाचे म्हणजे सापेक्ष एंड-इफेक्टर ॲक्शन स्पेस: N1.7 हे सध्याच्या पोझमधून डेल्टासचा अंदाज लावते, ज्यामुळे 20K तासांचे EgoScale मानवी व्हिडिओ रोबोट पॉलिसीमध्ये हस्तांतरित होतात. तपशील N1.7 पृष्ठावर, प्रक्रिया N1.7 ऑन SO-100 मार्गदर्शिकेत.

GR00T N1.5

तेच 3 B स्केल, ईगल 2 बॅकबोन, सिगलिप2 आणि T5, फ्लो-मॅचिंग डीआयटी हेड. हे तुमच्याकडे आधीपासून असलेल्या चा विस्तार करण्यासाठी अस्तित्वात आहे. दोन गोष्टींमुळे ते एक खराब डीफॉल्ट ठरते: त्याचे वजन 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 कार्डवर नमूद केली आहे: पोर्ट केवळ फ्लो-मॅचिंग ॲक्शन हेड वाहून नेते. सबटास्क प्रेडिक्शन, ॲक्शन टोकेनायझेशन आणि आरएल (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 मधील ॲक्शन चंकिंग ट्रान्सफॉर्मर सुमारे 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 पिक-अँड-प्लेसवर स्वच्छ जोडी दोन्ही सिंगल-टास्क आहे: वितरणात 90 विरुद्ध 70, 50 विरुद्ध 40 त्याच्या बाहेर. तुलना करा 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 Open Model License अंतर्गत ठेवतात.

तुम्ही प्रत्यक्षात चालवणार असलेले डीफॉल्ट

प्रत्येक ट्रेनर फॉर्म डीफॉल्टसह येतो आणि ते मनमानी नसतात. ACT चे LeRobot चे स्वतःचे आहेत: बॅच 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 चे 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 साठी पन्नास, आणि SmolVLA च्या तीस साठी जागा मोकळी करते. प्रत्येक भिन्नता पातळ न पसरवता पुन्हा करा: 50 क्यूब पोझिशन्समध्ये 50 एपिसोड्स प्रशिक्षित केले, जिथे 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 VRAM ची शिफारस करते. 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 टक्के फरक असल्याने , पुनरुत्पादन अंदाजे असते. आणि प्लॅटफॉर्म बाजू आहे.

दोन पर्यंत खाली आले आहे का? आणि . कच्च्या पंक्ती एरिना नोंदींमध्ये आहेत: , , आणि .

हे प्लॅटफॉर्म तुम्हाला कुठे मदत करत नाही

• ते रिमोट इन्फरन्स जलद करू शकत नाही. 20 ते 485 ms चा लूप मॉडेलचा आहे; इंटरनेट राऊंड ट्रिप्स त्यात भर घालतात.
• ते तुमच्या स्वतःच्या हार्डवेअरवर GR00T किंवा Pi0.5 ला फाइन-ट्यून करू शकत नाही. येथे दोन्ही केवळ क्लाउड-आधारित आहेत; फक्त SmolVLA आणि ACT स्थानिक पातळीवर चालतात.
• ते डेटासेट दुरुस्त करू शकत नाही. लॉस कमी होतो पण पॉलिसी काही करत नाही ही डेटाची समस्या आहे, फक्त एका सेटअपमध्ये काम करणारी पॉलिसी ही कव्हरेजची समस्या आहे.
• ते GR00T रन पुनरुत्पादक बनवू शकत नाही: कारण अपस्ट्रीम कॉन्फिगमध्ये सीड फील्ड नाही.

एक निवडणे आणि पुढे जाणे

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

प्लॅटफॉर्म वॉकथ्रू: तुमची पहिली पॉलिसी प्रशिक्षित करा, नंतर तुमची पहिली पॉलिसी चालवा. प्रशिक्षण डॉक्स आणि डेटासेट डॉक्स फॉर्म आणि फॉरमॅट कव्हर करतात; SO-100 पृष्ठ आणि संपूर्ण SO-100 मार्गदर्शक बिल्ड आणि कॅलिब्रेशन कव्हर करतात. पार्श्वभूमी: VLA विहंगावलोकन आणि Pi0 फ्लो-मॅचिंग लेख. तुमचा यश दर वाढवणारे आहे डेटा गुणवत्ता मार्गदर्शक.