Maliit na VLA Models: TinyVLA, SmolVLA at ang Kaso ng Sub-1B

Halos bawat modelo ng vision-language-action na isinusulat ay nagpapalagay ng datacentre card. Ang OpenVLA ay may 7 B na parameter. GR00T N1.7 at Pi0.5 ay humigit-kumulang 3 B at nangangailangan ng A100 80 GB para sa fine-tuning. Kung ang card sa iyong desk ay isang 4090, ang klase ng modelong iyon ay hindi mo maaabot.

Dalawang papel ang nagsasabing hindi mo ito kailangan. Ang TinyVLA (arXiv 2409.12514, tinanggap ng IEEE Robotics and Automation Letters noong Pebrero 2025) ay bumubuo ng isang VLA mula sa isang 400 M hanggang 1.3 B na backbone kasama ang isang diffusion action head. SmolVLA (arXiv 2506.01844, isinumite noong 2 Hunyo 2025) ay naglalaman ng 450 M na parameter na may open weights, open data at isang script na tumatakbo sa isang consumer card. Narito ang sinukat ng pareho, at kung saan humihinto ang argumento ng sub-1 B.

Ano ang tunay na maituturing na maliit na VLA

Ang bilang ng parameter sa isang model card ay hindi iisang numero. Maaari itong mangahulugan ng kabuuang weights, weights na na-load sa inference, o weights na tumatanggap ng gradients sa panahon ng . Iniulat ng TinyVLA ang pareho, at malaki ang agwat: Ang TinyVLA-H ay 1.3 B sa kabuuan ngunit 143 M ang nate-train, dahil ang vision tower at karamihan sa language model ay nananatiling frozen habang ang LoRA adapters at ang action head ay gumagalaw. Inilalagay ng papel ang trainable share sa humigit-kumulang 5 porsiyento.

Dalawang row ang karapat-dapat pagtalunan. Ang sa humigit-kumulang 80 M ay mas maliit kaysa sa lahat ng iba pa rito ngunit walang language model, kaya hindi ito VLA: natututo ito ng isang gawain at hindi maaaring utusan na gumawa ng iba. Ang sa 27 M ay kinondisyon sa pamamagitan ng isang T5-Base text encoder, hindi isang LLM backbone. Magandang baselines, ngunit wala sa mga ito ang nagbibigay sa iyo ng instruction following na ipinahihiwatig ng label.

TinyVLA: ang bilis ay nagmumula sa ulo, hindi sa backbone

Ang malinaw na pagbasa ay ginawa nilang mas maliit ang language model, kaya ito ay bumilis. Sinasabi ng ablation ng papel ang kabaligtaran. Ang pagpapalit ng OpenVLA's 7 B backbone sa isang humigit-kumulang 1 B ay nagpababa ng per-action prediction mula 292 ms tungo 140 ms, isang 2x na pagtaas. Ang TinyVLA-H, sa katulad na bilang ng parameter, ay tumatakbo sa 14 ms sa parehong card. Ang iba pang 10x ay ang action head.

Ang OpenVLA ay naglalabas ng mga aksyon bilang discretised tokens sa pamamagitan ng language model head, isa bawat dimensyon ng aksyon, nang autoregressively. Ang TinyVLA ay nagkakabit ng diffusion decoder na gumagawa ng buong chunk sa isang shot. Ang Talahanayan V ay naglalaman ng arkitektura sa TinyVLA-H at pinapalitan lamang ang head, sa parehong limang real-robot tasks. Ito ang pinakamalinaw na ebidensya sa alinmang papel para sa argumento flow matching na ginagawa ng mga patakaran, at ang dahilan Pi0 ay lumayo sa token decoding.

Ano ang nakuha ng TinyVLA

Ang bimanual row ay may nakakainip na paliwanag na ibinigay mismo ng papel: Ang OpenVLA ay sinanay sa Open X-Embodiment, na binubuo lamang ng data ng iisang braso, kaya ang action space ng dalawang braso ay wala sa distribusyon at nakakuha ito ng zero. Ang diffusion policy baseline ay tinalo ang TinyVLA-H sa dalawa sa tatlong gawain na iyon. Background sa ang Open X-Embodiment write-up.

Ang TinyVLA repo, simula Agosto 2026

Maganda ang papel. Ang code ay isang research drop. Ang repository ay github.com/liyaxuanliyaxuan/TinyVLA; ang README nito ay nagtatakda ng petsa ng paglabas ng code sa 17 Pebrero 2025 at ang huling commit ay 11 Marso 2025. Ayos para sa pag-reproduce ng isang papel, isang problema kung gusto mo ng isang maintained library.

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 .

Hindi rin binabasa ng TinyVLA ang mga dataset ng LeRobot. Ang format nito ay ACT-style HDF5: action, language_raw, at isang observations group na may multi-view images, joint_positions, qpos at qvel. Ang repo ay naglalaman ng data_utils/rlds_to_h5py.py para sa RLDS input, at bawat task ay manu-manong nakarehistro sa aloha_scripts/constants.py kasama ang dataset_dir, episode_len at camera_names nito. Kung ang iyong mga episode ay nagmula sa lerobot o sa kliyente sa desktop, ikaw ang may-ari ng conversion.

# 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 ay nagpapalagay ng isang eight-card node. Itakda ito sa 1 at bawasan ang batch size nang mas mababa sa 32. Walang single-GPU variant na inilabas sa upstream, kaya hindi maaaring patakbuhin ang command nang eksakto sa isang 4090.
• --deepspeed scripts/zero2.json ay tumuturo sa isang file na wala sa top-level scripts directory. Ang mga DeepSpeed config ay matatagpuan sa llava-pythia/scripts/zero2.json. Ayusin ang path bago ang iyong unang pagpapatakbo.
• Kinakailangan ng README na ang pangalan ng output directory ay naglalaman ng llava_pythia, kasama ang lora kung naka-enable ang LoRA.
• Ang backbone ay isang hiwalay na download: lesjie/Llava-Pythia-400M, -700M o -1.3B. Walang iisang base checkpoint na itinuturo mo ang isang policy sa paraan ng pagturo mo sa lerobot/smolvla_base.

SmolVLA: ang sub-1 B model na maaari mong patakbuhin ngayong hapon

Ginagawa ng SmolVLA ang parehong argumento sa loob ng isang pinapanatiling library. Ito ay may 450 M parameters sa isang SmolVLM2-500M-Video-Instruct backbone, at ang kahusayan ay nagmumula sa mga setting na mababasa mo mula sa configuration_smolvla.py sa halip na mula sa isang pahayag tungkol sa pagiging maliit.

Ang pretraining ay gumamit ng 481 community LeRobot datasets, 22.9 K episodes at 10.6 M frames sa 4 GPUs, 200000 steps sa isang global batch na 256; tinatantya ng papel ang buong proyekto sa humigit-kumulang 30 K GPU hours. Isang numero na dapat bantayan: sinasabi ng Hugging Face launch blog na 487 curated datasets kung saan ang talahanayan ng papel ay nagsasaad ng 481. Gagamitin namin ang figure ng papel at itatala ang pagkakaiba.

Isang aksidente ang nakatulong: ang Meta-World table ng SmolVLA paper ay naglalaman ng sariling inilathalang numero ng TinyVLA bilang baseline, kaya sa pagkakataong ito, parehong modelo ay nasa isang table, ang SmolVLA-0.45B sa 57.3 laban sa TinyVLA-H sa 31.6. Iniulat din nito na ang pagsasanay ng SmolVLA ay humigit-kumulang 40 porsiyentong mas mabilis kaysa sa Pi0 sa 6x na mas kaunting memorya. Lahat ng ito ay nagmula sa mga may-akda ng SmolVLA; ang entry sa arena ay nagli-link ng bawat halaga sa pinagmulan nito.

Saan ginugugol ng SmolVLA ang oras nito

Inilista ng AY-Robots ang SmolVLA sa 245 ms bawat hakbang ng aksyon at ACT sa 20 ms sa katalogo ng patakaran. Iniulat ng TinyVLA ang 14 ms bawat prediksyon ng aksyon. Ang mga numerong iyon ay hindi maihahambing, at ang pagtrato sa mga ito na parang maihahambing ay ang pinakakaraniwang pagkakamali sa paksang ito: ang ilan ay nagtatala ng isang forward pass, ang ilan ay hinahati ang pass na iyon sa isang chunk kapag pag-chunk ng aksyon ay nag-aamortize nito.

• Ang SmolVLA ay naglalabas ng 50 aksyon bawat forward pass at isinasagawa ang lahat ng 50. Sa 30 fps na ginagamit ng papel sa mga totoong robot, ang isang inference ay sumasaklaw ng humigit-kumulang 1.7 segundo ng paggalaw.
• Kinakalkula ng asynchronous inference ang susunod na chunk habang ang kasalukuyan ay isinasagawa pa rin: 9.7 s average na pagkumpleto ng gawain laban sa 13.75 s synchronous, humigit-kumulang 30 porsiyentong mas mabilis, at 19 pick-and-place cycles sa isang nakapirming 60-segundong window laban sa 9.
• Ang mga rate ng tagumpay ay maihahambing sa halip na mas mahusay, 78.3 synchronous laban sa 73.3 asynchronous. Ang Async ay bumibili ng throughput, hindi accuracy.
• Itinatago ng chunking ang compute latency, hindi network latency, at ginagawa nitong hindi gaanong reaktibo ang patakaran dahil ito ay nakatuon sa 50 aksyon.

Fine-tuning ng SmolVLA sa isang consumer card

Ang manual na paraan, sa lerobot 0.6.1, ang kasalukuyang PyPI release noong 23 August 2026. Lahat ng nasa ibaba ay nagmula sa Hugging Face lerobot SmolVLA documentation, na nakuha sa parehong araw; ang ginabayang bersyon ay mas madali.

1. 1
   I-install ang lerobot kasama ang smolvla extra

   Ang mga dependency ng SmolVLA ay isang opsyonal na karagdagan, hindi bahagi ng pangunahing pag-install. Ang pag-install nang wala ito at pagkatapos ay magtaka kung bakit hindi kilala ang uri ng patakaran ay isang karaniwang kalahating oras na nawala.

   bash

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

2. 2
   Kumuha ng dataset na may sapat na episode

   Inirerekomenda ng mga docs ang humigit-kumulang 50 episode at sinasabing hindi sapat ang parehong gawain na may 25. Itinatakda ng AY-Robots ang minimum sa 30. Mag-record ng sarili mo, o magsimula mula sa direktoryo ng dataset.

   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
   Simulan ang fine-tune

   Ang command mula sa lerobot guide, hindi binago. Inilalagay ng mga docs ang 20000 steps sa humigit-kumulang 4 na oras sa isang A100. Sa isang 24 GB card, asahan ang mas matagal at sukatin ito.

   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
   Bawasan ang batch size hanggang sa magkasya

   Ang batch_size=64 ay isang dokumentadong halimbawa, hindi isang pangako tungkol sa iyong card. Pinapayuhan ng mga docs na magsimula sa maliit at dagdagan habang nananatiling maikli ang mga oras ng paglo-load.

   bash

   lerobot-train --help

5. 5
   I-roll out ang checkpoint sa braso

   Parehong library, isang command. Ang mga real-time chunking flags ay naka-comment out sa mga docs at ang mga ito ang dapat gamitin sa low-power hardware.

   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

Dalawang paraan upang makakuha ng maliit na VLA sa isang braso

Kapag mali ang pagpili ng maliit na modelo

Mas maingat ang parehong papel dito kaysa sa mga buod. Ang pagsusuri sa pagkabigo ng TinyVLA ay partikular: ang 0.4 B na variant ay nabigo nang tatlong beses sa maling pagbasa ng instruksyon, na iniuugnay ng mga may-akda sa limitadong pag-unawa sa wika sa mas maliit na VLM, at nawala ang mode na iyon sa 1.3 B. Ipinapakita ng SmolVLA ang parehong kurba mula sa kabilang dulo: ang 2.25 B na bersyon ng magkaparehong arkitektura ay nakakuha ng 88.75 sa LIBERO at 68.24 sa Meta-World laban sa 87.3 at 57.3 para sa 0.45 B na modelo.

Ang paghahambing na sulit gawin ay hindi TinyVLA laban sa SmolVLA. Ito ay SmolVLA laban sa ACT sa iyong sariling gawain, at ang papel ng SmolVLA ang argumento kung bakit. Sinanay na single-task na walang robotics pretraining, ang SmolVLA ay nag-average ng 40.0 sa tatlong SO-100 na gawain kung saan ang single-task ACT ay nakakuha ng 48.3. Ang nagpapataas nito sa 78.3 ay ang community pretraining plus multi-task training, hindi ang arkitektura lamang. Sa SO-101 lego task, parehong single-task, nanalo ang SmolVLA: 90 laban sa 70 sa distribution. Pagkatapos, SmolVLA laban sa Pi0.5 kung pinapayagan ng badyet.

Isang talahanayan ng desisyon na maaari mong pagbatayan

Para sa huling hilera, ang live na braso ay nag-stream ng pisikal na SO-100 na maaari mong kontrolin mula sa browser nang walang account, at ang tatlong paraan para makapagsimula ang sumasaklaw sa iba pa. Ang SO-100 ang reference na braso dito, humigit-kumulang 110 hanggang 150 EUR sa mga piyesa, na may kumpletong gabay sa pag-setup.

Ano ang susunod pagkatapos ng mga modelong wala pang 1 B

Ang pagpapaliit ng bilang ng parameter ay isang paraan upang maging mura ang isang VLA at hindi ito ang malinaw na nanalong paraan. OpenVLA-OFT (arXiv 2502.19645) ay pinapanatili ang 7 B backbone at binabago lamang kung paano ini-decode ang mga aksyon, nag-uulat ng 26x na pagtaas sa throughput ng pagbuo ng aksyon at pagtaas ng LIBERO mula 76.5 hanggang 97.1 porsyento. BitVLA (arXiv 2506.07530) ay ginagawang ternary ang bawat bigat ng isang 1-bit BitNet b1.58 2B4T backbone, nag-uulat ng 11.0x na mas kaunting memorya at 4.4x na mas mababang end-to-end latency habang tumutugma sa full-precision OpenVLA-OFT. X-VLA-0.9B (arXiv 2510.10274) ay nasa linya ng 1 B na may flow matching.

Ang karaniwang tema: ang action decoder, hindi ang language model, ang pinagmumulan ng latency. Tanungin kung paano naglalabas ng mga aksyon ang isang patakaran bago mo tanungin kung gaano karaming parameter ang mayroon ito. Ang arena ay may 85 modelo at 332 resulta, bawat isa ay naka-link sa pinagmulan nito; mayroong mas malawak na pangkalahatang-ideya sa aming panimula sa VLA.