छोटे VLA मॉडल: TinyVLA, SmolVLA और सब-1B केस

लगभग हर विजन-लैंग्वेज-एक्शन मॉडल जिसके बारे में लिखा जाता है, वह एक डेटासेंटर कार्ड मानता है। OpenVLA में 7 बिलियन पैरामीटर हैं। GR00T N1.7 और Pi0.5 लगभग 3 बिलियन हैं और फाइन-ट्यून करने के लिए एक A100 80 GB चाहते हैं। यदि आपके डेस्क पर कार्ड 4090 है, तो उस श्रेणी का मॉडल पहुंच से बाहर है।

दो पेपर तर्क देते हैं कि आपको इसकी आवश्यकता नहीं है। TinyVLA (arXiv 2409.12514, फरवरी 2025 में IEEE रोबोटिक्स एंड ऑटोमेशन लेटर्स द्वारा स्वीकृत) 400 मिलियन से 1.3 बिलियन बैकबोन और एक डिफ्यूजन एक्शन हेड से एक VLA बनाता है। SmolVLA (arXiv 2506.01844, 2 जून 2025 को प्रस्तुत) 450 मिलियन पैरामीटर खुले वज़न, खुले डेटा और एक स्क्रिप्ट के साथ भेजता है जो एक उपभोक्ता कार्ड पर चलती है। यहां बताया गया है कि दोनों ने क्या मापा, और जहां सब-1 बिलियन का तर्क मान्य नहीं रहता।

वास्तव में एक छोटा VLA क्या माना जाता है

एक मॉडल कार्ड पर पैरामीटर गणना एक संख्या नहीं होती है। इसका मतलब कुल भार, अनुमान के समय लोड किए गए भार, या वे भार हो सकते हैं जिन्हें ग्रेडिएंट प्राप्त होते हैं । TinyVLA दोनों की रिपोर्ट करता है, और अंतर बड़ा है: TinyVLA-H कुल 1.3 B है लेकिन 143 M प्रशिक्षित करने योग्य है, क्योंकि विजन टावर और अधिकांश भाषा मॉडल स्थिर रहते हैं जबकि LoRA एडेप्टर और एक्शन हेड चलते हैं। पेपर में प्रशिक्षित करने योग्य हिस्सेदारी लगभग 5 प्रतिशत बताई गई है।

दो पंक्तियों पर बहस करने लायक है। लगभग 80 M पर यहाँ बाकी सभी से छोटा है लेकिन इसमें कोई भाषा मॉडल नहीं है, इसलिए यह VLA नहीं है: यह एक कार्य सीखता है और इसे दूसरा करने के लिए नहीं कहा जा सकता। 27 M पर T5-बेस टेक्स्ट एनकोडर के माध्यम से कंडीशन किया जाता है, न कि LLM बैकबोन के माध्यम से। अच्छे बेसलाइन, लेकिन कोई भी आपको वह निर्देश पालन नहीं देता है जो लेबल इंगित करता है।

TinyVLA: गति हेड से आती है, बैकबोन से नहीं

स्पष्ट व्याख्या यह है कि उन्होंने भाषा मॉडल को छोटा कर दिया, जिससे वह तेज़ हो गया। पेपर का एब्लेशन इसके विपरीत कहता है। OpenVLA के 7 B बैकबोन को लगभग 1 B वाले से बदलने पर प्रति-एक्शन प्रेडिक्शन 292 ms से घटकर 140 ms हो गया, जो 2x का लाभ है। TinyVLA-H, तुलनीय पैरामीटर गणना पर, उसी कार्ड पर 14 ms पर चलता है। अन्य 10x एक्शन हेड है।

OpenVLA भाषा मॉडल हेड के माध्यम से असतत टोकन के रूप में एक्शन उत्सर्जित करता है, प्रति एक्शन आयाम एक, ऑटोरेग्रेसिव रूप से। TinyVLA एक डिफ्यूजन डिकोडर संलग्न करता है जो पूरे चंक को एक ही बार में उत्पन्न करता है। तालिका V TinyVLA-H पर आर्किटेक्चर को दर्शाती है और उसी पांच वास्तविक-रोबोट कार्यों पर केवल हेड को बदलती है। यह किसी भी पेपर में इस तर्क के लिए सबसे स्पष्ट प्रमाण है कि फ्लो मैचिंग नीतियां बनाती हैं, और यही कारण है कि Pi0 टोकन डिकोडिंग से दूर चला गया।

TinyVLA ने क्या स्कोर किया

द्वि-मैनुअल पंक्ति की एक नीरस व्याख्या है जो पेपर स्वयं देता है: OpenVLA को Open X-Embodiment पर प्रीट्रेन किया गया है, जिसमें पूरी तरह से सिंगल-आर्म डेटा शामिल है, इसलिए दो-आर्म एक्शन स्पेस डिस्ट्रीब्यूशन से बाहर है और यह शून्य स्कोर करता है। डिफ्यूजन पॉलिसी बेसलाइन उन तीन कार्यों में से दो पर TinyVLA-H को हरा देती है। पृष्ठभूमि ओपन एक्स-एम्बॉडमेंट राइट-अप.

TinyVLA रेपो, अगस्त 2026 तक

यह पेपर अच्छा है। कोड एक रिसर्च ड्रॉप है। रिपॉजिटरी github.com/liyaxuanliyaxuan/TinyVLA है; इसकी README कोड रिलीज़ की तारीख 17 फरवरी 2025 और अंतिम कमिट 11 मार्च 2025 बताती है। एक पेपर को पुनरुत्पादित करने के लिए ठीक है, लेकिन यदि आप एक अनुरक्षित लाइब्रेरी चाहते हैं तो यह एक समस्या है।

git clone https://github.com/liyaxuanliyaxuan/TinyVLA
conda create -n tinyvla python=3.10 -y
conda activate tinyvla
pip install --upgrade pip
pip install -r requirements.txt
cd policy_heads && pip install -e .
cd ../llava-pythia && pip install -e .

TinyVLA भी नहीं पढ़ता है LeRobot डेटासेट. इसका प्रारूप ACT-शैली का HDF5 है: एक्शन, language_raw, और मल्टी-व्यू इमेज, joint_positions, qpos और qvel के साथ एक ऑब्जर्वेशन ग्रुप। रेपो RLDS इनपुट के लिए data_utils/rlds_to_h5py.py भेजता है, और प्रत्येक कार्य को aloha_scripts/constants.py में उसके dataset_dir, episode_len और camera_names के साथ मैन्युअल रूप से पंजीकृत किया जाता है। यदि आपके एपिसोड lerobot या डेस्कटॉप क्लाइंट से आए हैं, तो रूपांतरण की जिम्मेदारी आपकी है।

# scripts/train.sh, the real flags from the repository
ACTION_HEAD=droid_diffusion

deepspeed --master_port 29600 --num_gpus=8 --num_nodes=1 ./train_tinyvla.py \
  --deepspeed scripts/zero2.json \
  --lora_enable True \
  --lora_module 'vit llm' \
  --lora_r 64 \
  --lora_alpha 256 \
  --non_lora_lr 2e-5 \
  --task_name "example_task_config" \
  --model_name_or_path /path/to/pretrained_vlm \
  --freeze_vision_tower True \
  --freeze_backbone True \
  --bf16 True \
  --max_steps 10000 \
  --per_device_train_batch_size 32 \
  --gradient_accumulation_steps 1 \
  --learning_rate 2e-4 \
  --lr_scheduler_type "cosine" \
  --warmup_ratio 0.005 \
  --save_steps 1000 \
  --action_head_type $ACTION_HEAD \
  --use_state True \
  --window_size 6

• --num_gpus=8 एक आठ-कार्ड नोड मानता है। इसे 1 पर सेट करें और बैच आकार को 32 से काफी नीचे कर दें। कोई भी सिंगल-GPU वेरिएंट अपस्ट्रीम शिप नहीं होता है, इसलिए कमांड को 4090 पर हूबहू नहीं चलाया जा सकता है।
• --deepspeed scripts/zero2.json एक ऐसी फ़ाइल की ओर इशारा करता है जो टॉप-लेवल स्क्रिप्ट्स डायरेक्टरी में नहीं है। DeepSpeed कॉन्फ़िग llava-pythia/scripts/zero2.json पर शिप होते हैं। अपनी पहली रन से पहले पाथ को ठीक करें।
• README के लिए आवश्यक है कि आउटपुट डायरेक्टरी के नाम में llava_pythia शामिल हो, साथ ही यदि LoRA सक्षम है तो lora भी हो।
• बैकबोन एक अलग डाउनलोड है: lesjie/Llava-Pythia-400M, -700M या -1.3B। कोई एक बेस चेकपॉइंट नहीं है जिस पर आप एक पॉलिसी को इंगित कर सकें, जैसे आप lerobot/smolvla_base पर इंगित करते हैं।

SmolVLA: वह सब-1 B मॉडल जिसे आप आज दोपहर चला सकते हैं

SmolVLA एक अनुरक्षित लाइब्रेरी के भीतर वही तर्क प्रस्तुत करता है। यह SmolVLM2-500M-Video-Instruct बैकबोन पर 450 M पैरामीटर का है, और दक्षता उन सेटिंग्स से आती है जिन्हें आप configuration_smolvla.py से पढ़ सकते हैं, न कि छोटे होने के दावे से।

प्रीट्रेनिंग में 481 कम्युनिटी LeRobot डेटासेट, 22.9 K एपिसोड और 10.6 M फ़्रेम का उपयोग 4 GPUs पर, 256 के ग्लोबल बैच पर 200000 स्टेप्स के लिए किया गया; पेपर के अनुसार पूरे प्रोजेक्ट में लगभग 30 K GPU घंटे लगे। एक संख्या जिस पर ध्यान देना है: Hugging Face लॉन्च ब्लॉग में 487 क्यूरेटेड डेटासेट का उल्लेख है जबकि पेपर की तालिका में 481 कहा गया है। हम पेपर के आंकड़े का उपयोग करते हैं और इस असहमति को चिह्नित करते हैं।

एक संयोग सहायक है: SmolVLA पेपर की मेटा-वर्ल्ड तालिका में TinyVLA के अपने प्रकाशित नंबरों को एक आधार रेखा के रूप में शामिल किया गया है, इसलिए एक बार के लिए दोनों मॉडल एक ही तालिका में हैं, SmolVLA-0.45B 57.3 पर TinyVLA-H के 31.6 के मुकाबले। यह यह भी बताता है कि SmolVLA की ट्रेनिंग Pi0 की तुलना में लगभग 40 प्रतिशत तेज़ और 6 गुना कम मेमोरी पर होती है। यह सब SmolVLA के लेखकों से आता है; अखाड़ा प्रविष्टि प्रत्येक मान को उसके स्रोत से जोड़ता है।

SmolVLA अपना समय कहाँ व्यतीत करता है

AY-Robots SmolVLA को प्रति एक्शन स्टेप 245 ms और ACT को 20 ms पर नीति कैटलॉग में सूचीबद्ध करता है। TinyVLA प्रति एक्शन प्रेडिक्शन 14 ms की रिपोर्ट करता है। ये संख्याएँ तुलनीय नहीं हैं, और उन्हें ऐसा मानना इस विषय में सबसे आम गलती है: कुछ एक फॉरवर्ड पास का समय लेते हैं, कुछ उस पास को एक चंक में विभाजित करते हैं जब एक्शन चंकिंग इसे अमोर्टाइज़ करता है।

• SmolVLA प्रति फॉरवर्ड पास 50 एक्शन उत्सर्जित करता है और सभी 50 को निष्पादित करता है। 30 fps पर, जिसका उपयोग पेपर वास्तविक रोबोटों पर करता है, एक इन्फेरेंस लगभग 1.7 सेकंड की गति को कवर करता है।
• एसिंक्रोनस इन्फेरेंस अगले चंक की गणना करता है जबकि वर्तमान वाला अभी भी निष्पादित हो रहा होता है: 13.75 s सिंक्रोनस के मुकाबले 9.7 s औसत कार्य पूर्णता, लगभग 30 प्रतिशत तेज़, और एक निश्चित 60-सेकंड की विंडो में 9 के मुकाबले 19 पिक-एंड-प्लेस चक्र।
• सफलता दर बेहतर होने के बजाय तुलनीय थी, 73.3 एसिंक्रोनस के मुकाबले 78.3 सिंक्रोनस। एसिंक थ्रूपुट खरीदता है, सटीकता नहीं।
• चंकिंग कंप्यूट लेटेंसी को छुपाता है, नेटवर्क लेटेंसी को नहीं, और यह नीति को कम प्रतिक्रियाशील बनाता है क्योंकि यह 50 एक्शन के लिए प्रतिबद्ध है।

एक उपभोक्ता कार्ड पर SmolVLA की फाइन-ट्यूनिंग

मैनुअल तरीका, lerobot 0.6.1 पर, जो 23 अगस्त 2026 तक की वर्तमान PyPI रिलीज़ है। नीचे दी गई सभी जानकारी उसी दिन प्राप्त की गई Hugging Face lerobot SmolVLA डॉक्यूमेंटेशन से आती है; निर्देशित संस्करण अधिक सौम्य है।

1. 1
   smolvla अतिरिक्त के साथ lerobot स्थापित करें

   SmolVLA निर्भरताएँ एक वैकल्पिक अतिरिक्त हैं, जो मूल इंस्टॉलेशन का हिस्सा नहीं हैं। इसे स्थापित किए बिना और फिर यह सोचने में कि नीति का प्रकार अज्ञात क्यों है, आमतौर पर आधा घंटा बर्बाद हो जाता है।

   bash

   git clone https://github.com/huggingface/lerobot.git
   cd lerobot
   pip install -e ".[smolvla]"

2. 2
   पर्याप्त एपिसोड वाला डेटासेट प्राप्त करें

   दस्तावेज़ लगभग 50 एपिसोड की सलाह देते हैं और बताते हैं कि 25 के साथ वही कार्य पर्याप्त नहीं था। AY-Robots न्यूनतम 30 निर्धारित करता है। अपना खुद का रिकॉर्ड करें, या डेटासेट निर्देशिका से शुरू करें।

   bash

   # any LeRobotDataset on the Hub works as --dataset.repo_id
   # lerobot/svla_so100_pickplace is the paper's own 50-episode set:
   # 5 cube positions, 10 episodes each

3. 3
   फाइन-ट्यून शुरू करें

   lerobot गाइड से कमांड, अपरिवर्तित। दस्तावेज़ एक A100 पर 20000 चरणों को लगभग 4 घंटे बताते हैं। 24 GB कार्ड पर, अधिक समय की अपेक्षा करें और इसे मापें।

   bash

   cd lerobot && lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/mydataset \
     --batch_size=64 \
     --steps=20000 \
     --output_dir=outputs/train/my_smolvla \
     --job_name=my_smolvla_training \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   बैच आकार को तब तक कम करें जब तक वह फिट न हो जाए

   batch_size=64 एक दस्तावेज़ित उदाहरण है, आपके कार्ड के बारे में कोई वादा नहीं। दस्तावेज़ छोटे से शुरू करने और लोडिंग समय कम रहने तक बढ़ाने की सलाह देते हैं।

   bash

   lerobot-train --help

5. 5
   आर्म पर चेकपॉइंट रोल आउट करें

   वही लाइब्रेरी, एक कमांड। रियल-टाइम चंकिंग फ़्लैग दस्तावेज़ों में टिप्पणी किए गए हैं और कम-शक्ति वाले हार्डवेयर पर उपयोग करने के लिए हैं।

   bash

   lerobot-rollout \
     --strategy.type=base \
     --robot.type=so101_follower \
     --robot.port=/dev/ttyACM0 \
     --robot.id=my_blue_follower_arm \
     --robot.cameras="{ front: {type: opencv, index_or_path: 8, width: 640, height: 480, fps: 30}}" \
     --task="Grasp a lego block and put it in the bin." \
     --policy.path=HF_USER/FINETUNE_MODEL_NAME

एक छोटे VLA को आर्म पर लाने के दो तरीके

जब एक छोटा मॉडल गलत विकल्प होता है

दोनों पेपर सारांशों की तुलना में यहाँ अधिक सतर्क हैं। TinyVLA का विफलता विश्लेषण विशिष्ट है: 0.4 B वेरिएंट निर्देश को गलत पढ़ने के कारण तीन बार विफल रहा, जिसे लेखक छोटे VLM में सीमित भाषा समझ के लिए जिम्मेदार ठहराते हैं, और वह मोड 1.3 B पर गायब हो गया। SmolVLA दूसरे छोर से वही वक्र दिखाता है: समान आर्किटेक्चर का 2.25 B संस्करण LIBERO पर 88.75 और Meta-World पर 68.24 स्कोर करता है, जबकि 0.45 B मॉडल के लिए यह 87.3 और 57.3 है।

चलाने लायक तुलना TinyVLA बनाम SmolVLA नहीं है। यह आपके अपने कार्य पर SmolVLA बनाम ACT है, और SmolVLA पेपर इसका तर्क प्रस्तुत करता है। बिना रोबोटिक्स प्रीट्रेनिंग के सिंगल-टास्क प्रशिक्षित, SmolVLA ने तीन SO-100 कार्यों में औसतन 40.0 स्कोर किया, जहाँ सिंगल-टास्क ACT ने 48.3 का प्रबंधन किया। जो इसे 78.3 तक बढ़ाता है वह सामुदायिक प्रीट्रेनिंग और मल्टी-टास्क प्रशिक्षण है, न कि केवल आर्किटेक्चर। SO-101 लेगो कार्य पर, दोनों सिंगल-टास्क में, SmolVLA जीतता है: वितरण में 70 के मुकाबले 90। फिर SmolVLA बनाम Pi0.5 यदि बजट अनुमति देता है।

एक निर्णय तालिका जिस पर आप कार्रवाई कर सकते हैं

अंतिम पंक्ति के लिए, लाइव आर्म एक भौतिक SO-100 को स्ट्रीम करता है जिसे आप बिना खाते के ब्राउज़र से चला सकते हैं, और शुरू करने के तीन तरीके बाकी को कवर करते हैं। SO-100 यहाँ संदर्भ आर्म है, पुर्जों में लगभग 110 से 150 EUR का, एक पूर्ण सेटअप गाइड के साथ।

सब-1 बी मॉडल के बाद क्या आता है

पैरामीटर गणना को कम करना VLA को सस्ता बनाने का एक तरीका है और यह स्पष्ट रूप से जीतने वाला नहीं है। OpenVLA-OFT (arXiv 2502.19645) 7 B बैकबोन को बरकरार रखता है और केवल यह बदलता है कि क्रियाओं को कैसे डीकोड किया जाता है, क्रिया जनरेशन थ्रूपुट में 26x वृद्धि और LIBERO में 76.5 से 97.1 प्रतिशत तक की वृद्धि की रिपोर्ट करता है। BitVLA (arXiv 2506.07530) 1-बिट BitNet b1.58 2B4T बैकबोन के प्रत्येक भार को टर्नरी बनाता है, 11.0x कम मेमोरी और 4.4x कम एंड-टू-एंड लेटेंसी की रिपोर्ट करता है जबकि पूर्ण-परिशुद्धता OpenVLA-OFT से मेल खाता है। X-VLA-0.9B (arXiv 2510.10274) फ्लो मैचिंग के साथ 1 B लाइन पर बैठता है।

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