Små VLA-modeller: TinyVLA, SmolVLA og tilfellet under 1 milliard parametere

Nesten hver visjon-språk-handling-modell som det skrives om, forutsetter et datasenterkort. OpenVLA har 7 milliarder parametere. GR00T N1.7 og Pi0.5 er rundt 3 milliarder og krever et A100 80 GB for finjustering. Hvis kortet på skrivebordet ditt er et 4090, er den modellklassen utenfor rekkevidde.

To artikler hevder at du ikke trenger det. TinyVLA (arXiv 2409.12514, akseptert av IEEE Robotics and Automation Letters i februar 2025) bygger en VLA fra en 400 millioner til 1,3 milliarder ryggrad pluss et diffusjons-handlingshode. SmolVLA (arXiv 2506.01844, innsendt 2. juni 2025) leveres med 450 millioner parametere med åpne vekter, åpne data og et skript som kjører på ett forbrukerkort. Her er hva begge målte, og hvor argumentet om under 1 milliard slutter å holde stikk.

Hva som faktisk regnes som en liten VLA

Antall parametere på et modellkort er ikke ett tall. Det kan bety totale vekter, vekter lastet under inferens, eller vekter som mottar gradienter under . TinyVLA rapporterer begge deler, og gapet er stort: TinyVLA-H er 1,3 B totalt, men 143 M trenbart, fordi visjonstårnet og det meste av språkmodellen forblir frosset mens LoRA-adaptere og handlingshodet beveger seg. Artikkelen angir den trenbare andelen til omtrent 5 prosent.

To rader er verdt å diskutere. på omtrent 80 M er mindre enn alt annet her, men har ingen språkmodell, så det er ikke en VLA: den lærer én oppgave og kan ikke bes om å gjøre en annen. på 27 M er betinget gjennom en T5-Base tekst-enkoder, ikke en LLM-ryggrad. Gode grunnlinjer, ingen av dem gir deg instruksjonsfølgingen etiketten antyder.

TinyVLA: hastigheten kommer fra hodet, ikke ryggraden

Den åpenbare tolkningen er at de gjorde språkmodellen mindre, slik at den ble raskere. Artikkelens ablasjonsstudie sier noe annet. Å bytte ut OpenVLAs 7 B ryggrad med en på omtrent 1 B reduserte prediksjon per handling fra 292 ms til 140 ms, en 2x forbedring. TinyVLA-H, med et sammenlignbart antall parametere, kjører på 14 ms på samme kort. De andre 10x kommer fra handlingshodet.

OpenVLA sender ut handlinger som diskretiserte tokens gjennom språkmodellhodet, ett per handlingsdimensjon, autoregressivt. TinyVLA kobler til en diffusjonsdekoder som produserer hele blokken i ett skudd. Tabell V viser arkitekturen til TinyVLA-H og bytter kun hodet, på de samme fem virkelige robot-oppgavene. Det er det reneste beviset i begge artiklene for argumentet flyt-matching policyer fremsetter, og grunnen til at Pi0 gikk bort fra token-dekoding.

Hva TinyVLA oppnådde

Den bimanuelle raden har en kjedelig forklaring som artikkelen selv gir: OpenVLA er forhåndstrent på Open X-Embodiment, som utelukkende består av data fra enkeltarmer, så et handlingsrom med to armer er utenfor distribusjonen og får null poeng. Diffusjonspolicy-baselinen slår TinyVLA-H på to av disse tre oppgavene. Bakgrunn i Open X-Embodiment-artikkelen.

TinyVLA-repoet, per august 2026

Artikkelen er god. Koden er et forskningsutkast. Repositoriet er github.com/liyaxuanliyaxuan/TinyVLA; README-filen daterer kodeutgivelsen til 17. februar 2025 og den siste committen er 11. mars 2025. Greit for å reprodusere en artikkel, et problem hvis du ønsket et vedlikeholdt bibliotek.

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 leser heller ikke LeRobot datasett. Formatet er ACT-stil HDF5: action, language_raw, og en observasjonsgruppe med flervisningsbilder, joint_positions, qpos og qvel. Depotet leverer data_utils/rlds_to_h5py.py for RLDS-input, og hver oppgave registreres manuelt i aloha_scripts/constants.py med sin dataset_dir, episode_len og camera_names. Hvis dine episoder kom fra lerobot eller skrivebordsklienten, eier du konverteringen.

# 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 antar en node med åtte kort. Sett den til 1 og reduser batchstørrelsen godt under 32. Ingen enkelt-GPU-variant leveres oppstrøms, så kommandoen kan ikke kjøres nøyaktig som den er på et 4090.
• --deepspeed scripts/zero2.json peker på en fil som ikke er i toppnivåets scripts-katalog. DeepSpeed-konfigurasjonene leveres i llava-pythia/scripts/zero2.json. Fiks stien før din første kjøring.
• README krever at navnet på utdatakatalogen inneholder llava_pythia, pluss lora hvis LoRA er aktivert.
• Ryggraden er en separat nedlasting: lesjie/Llava-Pythia-400M, -700M or -1.3B. Det finnes ingen enkelt basis-sjekkpunkt du peker en policy mot på samme måte som du peker mot lerobot/smolvla_base.

SmolVLA: modellen under 1 milliard parametere du kan kjøre i ettermiddag

SmolVLA fremfører det samme argumentet i et vedlikeholdt bibliotek. Den har 450 millioner parametere på en SmolVLM2-500M-Video-Instruct ryggrad, og effektiviteten kommer fra innstillinger du kan lese ut av configuration_smolvla.py, snarere enn fra en påstand om å være liten.

Forhåndstrening brukte 481 LeRobot-datasett fra fellesskapet, 22,9 K episoder og 10,6 M rammer på 4 GPU-er, 200000 trinn med en global batchstørrelse på 256; artikkelen anslår hele prosjektet til omtrent 30 K GPU-timer. Ett tall å merke seg: Hugging Face-lanseringsbloggen sier 487 kuraterte datasett der artikkelens tabell sier 481. Vi bruker tallet fra artikkelen og flagger uenigheten.

En tilfeldighet hjelper: SmolVLA-artikkelens Meta-World-tabell inneholder TinyVLAs egne publiserte tall som en baseline, så for en gangs skyld sitter begge modellene i én tabell, SmolVLA-0.45B på 57.3 mot TinyVLA-H på 31.6. Den rapporterer også at SmolVLA-trening er rundt 40 prosent raskere enn Pi0 med 6x mindre minne. Alt dette kommer fra SmolVLA-forfatterne; den arenaoppføringen lenker hver verdi til sin kilde.

Hvor SmolVLA bruker tiden sin

AY-Robots lister SmolVLA til 245 ms per handlingstrinn og ACT til 20 ms i policykatalogen. TinyVLA rapporterer 14 ms per handlingsprediksjon. Disse tallene er ikke sammenlignbare, og å behandle dem som om de var det, er den vanligste feilen i dette emnet: noen måler én fremoverpasning, noen deler den pasningen over en 'chunk' når handlings-chunking amortiserer den.

• SmolVLA sender ut 50 handlinger per fremoverpasning og utfører alle 50. Med 30 fps som artikkelen bruker på ekte roboter, dekker én inferens omtrent 1.7 sekunder med bevegelse.
• Asynkron inferens beregner neste 'chunk' mens den nåværende fortsatt utføres: 9.7 s gjennomsnittlig oppgavefullføring mot 13.75 s synkron, omtrent 30 prosent raskere, og 19 'pick-and-place'-sykluser i et fast 60-sekunders vindu mot 9.
• Suksessratene var sammenlignbare snarere enn bedre, 78.3 synkron mot 73.3 asynkron. Asynkronitet kjøper gjennomstrømning, ikke nøyaktighet.
• Chunking skjuler beregningslatens, ikke nettverkslatens, og det gjør policyen mindre reaktiv fordi den er forpliktet til 50 handlinger.

Finjustering av SmolVLA på ett forbrukerkort

Den manuelle veien, på lerobot 0.6.1, den nåværende PyPI-utgivelsen per 23. august 2026. Alt nedenfor kommer fra Hugging Face lerobot SmolVLA-dokumentasjonen, hentet samme dag; den guidede versjonen er mildere.

1. 1
   Installer lerobot med smolvla-tillegget

   SmolVLA-avhengighetene er et valgfritt tillegg, ikke en del av basisinstallasjonen. Å installere uten det og deretter lure på hvorfor policytypen er ukjent, er en vanlig halvtime tapt.

   bash

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

2. 2
   Skaff et datasett med nok episoder

   Dokumentasjonen anbefaler rundt 50 episoder og sier at den samme oppgaven med 25 ikke var nok. AY-Robots setter minimum til 30. Ta opp dine egne, eller start fra datasettkatalogen.

   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
   Start finjusteringen

   Kommandoen fra lerobot-guiden, uendret. Dokumentasjonen anslår 20000 steg til omtrent 4 timer på én A100. På et 24 GB-kort, forvent lengre tid og mål det.

   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
   Reduser batch-størrelsen til den passer

   batch_size=64 er et dokumentert eksempel, ikke et løfte om kortet ditt. Dokumentasjonen anbefaler å starte smått og øke mens lastetidene forblir korte.

   bash

   lerobot-train --help

5. 5
   Rull ut sjekkpunktet på armen

   Samme bibliotek, én kommando. Flaggene for sanntids-chunking er kommentert ut i dokumentasjonen og er de man bør bruke på maskinvare med lav effekt.

   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

To måter å få en liten VLA på en arm

Når en liten modell er feil valg

Begge artiklene er mer forsiktige her enn sammendragene er. TinyVLAs feilanalyse er spesifikk: 0,4 B-varianten feilet tre ganger ved å feiltolke instruksjonen, noe forfatterne tilskriver begrenset språkforståelse i den mindre VLM-en, og den modusen forsvant ved 1,3 B. SmolVLA viser den samme kurven fra den andre enden: 2,25 B-versjonen av den identiske arkitekturen scorer 88,75 på LIBERO og 68,24 på Meta-World, mot 87,3 og 57,3 for 0,45 B-modellen.

Sammenligningen verdt å kjøre er ikke TinyVLA mot SmolVLA. Det er SmolVLA mot ACT på din egen oppgave, og SmolVLA-artikkelen er argumentet for hvorfor. Trent som enkelt-oppgave uten robotikk-forhåndstrening, oppnådde SmolVLA et gjennomsnitt på 40,0 over tre SO-100-oppgaver der enkelt-oppgave ACT klarte 48,3. Det som løfter den til 78,3 er fellesskaps-forhåndstrening pluss fleroppgave-trening, ikke arkitekturen alene. På SO-101 lego-oppgaven, begge enkelt-oppgave, vinner SmolVLA: 90 mot 70 i distribusjon. Deretter SmolVLA mot Pi0.5 hvis budsjettet tillater det.

En beslutningstabell du kan handle ut fra

For den siste raden, den levende armen strømmer en fysisk SO-100 du kan styre fra nettleseren uten konto, og de tre måtene å starte på dekker resten. SO-100 er referansearmen her, omtrent 110 til 150 EUR i deler, med en komplett oppsettguide.

Hva kommer etter modellene under 1 B

Å redusere antall parametere er én måte å gjøre en VLA billig på, og ikke åpenbart den vinnende. OpenVLA-OFT (arXiv 2502.19645) beholder 7 B-ryggraden og endrer kun hvordan handlinger dekodes, og rapporterer en 26x økning i gjennomstrømning for handlinggenerering og LIBERO som stiger fra 76.5 til 97.1 prosent. BitVLA (arXiv 2506.07530) gjør hver vekt av en 1-bit BitNet b1.58 2B4T-ryggrad ternær, og rapporterer 11.0x mindre minne og 4.4x lavere ende-til-ende-latens samtidig som den matcher full-presisjons OpenVLA-OFT. X-VLA-0.9B (arXiv 2510.10274) ligger på 1 B-linjen med strømmatching.

Den røde tråden: handlingsdekoderen, ikke språkmodellen, er der latensen ligger. Spør hvordan en policy sender ut handlinger før du spør hvor mange parametere den har. Arenaen har 85 modeller og 332 resultater, hver koblet til sin kilde; det er en bredere oversikt i vår VLA-introduksjon.