Små VLA-modeller: TinyVLA, SmolVLA og tilfældet under 1 milliard parametre

Næsten enhver vision-sprog-handlingsmodel der skrives om, antager et datacentrekort. OpenVLA er 7 mia. parametre. GR00T N1.7 og Pi0.5 er omkring 3 mia. og kræver et A100 80 GB for finjustering. Hvis kortet på dit skrivebord er et 4090, er den modelklasse uden for rækkevidde.

To artikler argumenterer for, at du ikke behøver det. TinyVLA (arXiv 2409.12514, accepteret af IEEE Robotics and Automation Letters i februar 2025) bygger en VLA fra en 400 mio. til 1,3 mia. backbone plus et diffusion action head. SmolVLA (arXiv 2506.01844, indsendt 2. juni 2025) leveres med 450 mio. parametre med åbne vægte, åbne data og et script, der kører på ét forbrugerkort. Her er, hvad begge målte, og hvor argumentet om under 1 mia. holder op med at gælde.

Hvad der faktisk tæller som en lille VLA

Antallet af parametre på et modelkort er ikke ét tal. Det kan betyde samlede vægte, vægte indlæst ved inferens, eller vægte der modtager gradienter under . TinyVLA rapporterer begge, og forskellen er stor: TinyVLA-H er 1.3 B totalt, men 143 M trænbar, fordi vision-tårnet og det meste af sprogmodellen forbliver frosne, mens LoRA-adaptere og action-hovedet bevæger sig. Artiklen angiver den trænbare andel til omkring 5 procent.

To rækker er værd at diskutere. på cirka 80 M er mindre end alt andet her, men har ingen sprogmodel, så det er ikke en VLA: den lærer én opgave og kan ikke instrueres i at udføre en anden. på 27 M er betinget via en T5-Base tekst-encoder, ikke en LLM-backbone. Gode baselines, ingen af dem giver dig den instruktionsfølge, som etiketten antyder.

TinyVLA: hastigheden kommer fra hovedet, ikke rygraden

Den oplagte læsning er, at de gjorde sprogmodellen mindre, så den blev hurtigere. Artiklens ablationsstudie siger noget andet. Ved at udskifte OpenVLAs 7 B rygrad med en på cirka 1 B reduceredes forudsigelse per handling fra 292 ms til 140 ms, en 2x forbedring. TinyVLA-H, med et sammenligneligt antal parametre, kører med 14 ms på det samme kort. De resterende 10x skyldes handlingshovedet.

OpenVLA udsender handlinger som diskretiserede tokens gennem sprogmodelhovedet, én per handlingsdimension, autoregressivt. TinyVLA tilføjer en diffusionsdekoder, der producerer hele klumpen på én gang. Tabel V viser arkitekturen for TinyVLA-H og udskifter kun hovedet på de samme fem robotopgaver i den virkelige verden. Det er det tydeligste bevis i begge artikler for argumentet, som flow matching-politikker fremfører, og grunden til at Pi0 bevægede sig væk fra token-dekodning.

Hvad TinyVLA opnåede

Den bimanuelle række har en kedelig forklaring, som artiklen selv giver: OpenVLA er fortrænet på Open X-Embodiment, som udelukkende består af data fra enkeltarme, så et handlingsrum med to arme er uden for distribution og scorer nul. Diffusion policy-baselinen slår TinyVLA-H på to af de tre opgaver. Baggrund i beskrivelsen af Open X-Embodiment.

TinyVLA-repoet, pr. august 2026

Artiklen er god. Koden er et forskningsprojekt. Repository'et er github.com/liyaxuanliyaxuan/TinyVLA; dens README daterer kodeudgivelsen til 17. februar 2025, og den sidste commit er fra 11. marts 2025. Fint til at reproducere en artikel, et problem hvis man ønskede et vedligeholdt 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 læser heller ikke LeRobot datasæt. Dets format er ACT-stil HDF5: action, language_raw og en observationsgruppe med multi-view billeder, joint_positions, qpos og qvel. Depotet leverer data_utils/rlds_to_h5py.py til RLDS-input, og hver opgave registreres manuelt i aloha_scripts/constants.py med dens dataset_dir, episode_len og camera_names. Hvis dine episoder kom fra lerobot eller desktopklienten, ejer 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 antager en node med otte kort. Sæt den til 1 og reducer batchstørrelsen et godt stykke under 32. Ingen enkelt-GPU-variant leveres upstream, så kommandoen kan ikke køres verbatim på et 4090.
• --deepspeed scripts/zero2.json peger på en fil, der ikke er i scripts-mappen på øverste niveau. DeepSpeed-konfigurationerne leveres i llava-pythia/scripts/zero2.json. Ret stien før din første kørsel.
• README kræver, at navnet på outputmappen indeholder llava_pythia, plus lora hvis LoRA er aktiveret.
• Backbonen er en separat download: lesjie/Llava-Pythia-400M, -700M eller -1.3B. Der er ikke et enkelt base-checkpoint, du peger en politik på, som du peger på lerobot/smolvla_base.

SmolVLA: modellen under 1 mia. parametre, du kan køre i eftermiddag

SmolVLA fremfører det samme argument inden for et vedligeholdt bibliotek. Den har 450 mio. parametre på en SmolVLM2-500M-Video-Instruct backbone, og effektiviteten kommer fra indstillinger, du kan læse ud af configuration_smolvla.py, snarere end fra en påstand om at være lille.

Forudtræning brugte 481 LeRobot datasæt fra fællesskabet, 22,9 K episoder og 10,6 M frames på 4 GPU'er, 200000 trin med en global batchstørrelse på 256; artiklen anslår hele projektet til omkring 30 K GPU-timer. Et tal at bemærke: Hugging Face's lanceringsblog nævner 487 kuraterede datasæt, hvor artiklens tabel angiver 481. Vi bruger artiklens tal og noterer uoverensstemmelsen.

Én tilfældighed hjælper: SmolVLA-artiklens Meta-World-tabel indeholder TinyVLA's egne publicerede tal som en baseline, så for en gangs skyld sidder begge modeller i én tabel, SmolVLA-0.45B på 57.3 mod TinyVLA-H på 31.6. Den rapporterer også, at SmolVLA-træning er omkring 40 procent hurtigere end Pi0 med 6x mindre hukommelse. Alt dette kommer fra SmolVLA-forfatterne; arena-opslaget linker hver værdi til dens kilde.

Hvor SmolVLA bruger sin tid

AY-Robots angiver SmolVLA til 245 ms per handlingstrin og ACT til 20 ms i politik-kataloget. TinyVLA rapporterer 14 ms per handlingsforudsigelse. Disse tal er ikke sammenlignelige, og at behandle dem som om de var, er den mest almindelige fejl inden for dette emne: nogle måler én forward pass, nogle fordeler den pass over en chunk, når handlings-chunking amortiserer den.

• SmolVLA udsender 50 handlinger per forward pass og udfører alle 50. Ved de 30 fps, som artiklen bruger på rigtige robotter, dækker én inferens omkring 1.7 sekunders bevægelse.
• Asynkron inferens beregner den næste chunk, mens den nuværende stadig udføres: 9.7 s gennemsnitlig opgaveafslutning mod 13.75 s synkron, cirka 30 procent hurtigere, og 19 pick-and-place-cyklusser i et fast 60-sekunders vindue mod 9.
• Succesraterne var sammenlignelige snarere end bedre, 78.3 synkron mod 73.3 asynkron. Asynkronitet køber gennemløb, ikke nøjagtighed.
• Chunking skjuler beregningslatens, ikke netværkslatens, og det gør politikken mindre reaktiv, fordi den er forpligtet til 50 handlinger.

Finjustering af SmolVLA på ét forbrugerkort

Den manuelle vej, på lerobot 0.6.1, den nuværende PyPI-udgivelse pr. 23. august 2026. Alt nedenfor kommer fra Hugging Face lerobot SmolVLA-dokumentationen, hentet samme dag; den guidede version er mere skånsom.

1. 1
   Installer lerobot med smolvla-ekstraet

   SmolVLA-afhængighederne er et valgfrit ekstra, ikke en del af basisinstallationen. At installere uden det og derefter undre sig over, hvorfor politiktypen er ukendt, er en almindelig spildt halv time.

   bash

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

2. 2
   Skaf et datasæt med nok episoder

   Dokumentationen anbefaler omkring 50 episoder og angiver, at den samme opgave med 25 ikke var nok. AY-Robots sætter minimum til 30. Optag dine egne, eller start fra datasætmappen.

   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, uændret. Dokumentationen angiver 20000 trin til cirka 4 timer på en A100. På et 24 GB kort, forvent længere 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
   Reducer batchstørrelsen, indtil den passer

   batch_size=64 er et dokumenteret eksempel, ikke et løfte om dit kort. Dokumentationen råder til at starte småt og øge, så længe indlæsningstiderne forbliver korte.

   bash

   lerobot-train --help

5. 5
   Udrul checkpointet på armen

   Samme bibliotek, én kommando. Real-time chunking-flagene er kommenteret ud i dokumentationen og er dem, man skal bruge på hardware med lavt strømforbrug.

   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åder at få en lille VLA på en arm

Når en lille model er det forkerte valg

Begge artikler er mere forsigtige her, end resuméerne er. TinyVLAs fejlfindingsanalyse er specifik: 0,4 B-varianten fejlede tre gange ved at misforstå instruktionen, hvilket forfatterne tilskriver begrænset sprogforståelse i den mindre VLM, og den tilstand forsvandt ved 1,3 B. SmolVLA viser den samme kurve fra den anden ende: 2,25 B-versionen af den identiske arkitektur scorer 88,75 på LIBERO og 68,24 på Meta-World mod 87,3 og 57,3 for 0,45 B-modellen.

Sammenligningen, der er værd at køre, er ikke TinyVLA mod SmolVLA. Det er SmolVLA mod ACT på din egen opgave, og SmolVLA-artiklen er argumentet for hvorfor. Trænet enkelt-opgave uden robotik-fortræning, opnåede SmolVLA et gennemsnit på 40,0 på tværs af tre SO-100 opgaver, hvor enkelt-opgave ACT opnåede 48,3. Hvad der løfter den til 78,3 er fællesskabsfortræning plus multi-task træning, ikke arkitekturen alene. På SO-101 lego-opgaven, begge enkelt-opgave, vinder SmolVLA: 90 mod 70 i distribution. Derefter SmolVLA mod Pi0.5 hvis budgettet tillader det.

En beslutningstabel du kan handle ud fra

For den sidste række, den levende arm streamer en fysisk SO-100, du kan styre fra browseren uden en konto, og de tre måder at starte på dækker resten. Den SO-100 er referencearmen her, cirka 110 til 150 EUR i dele, med en komplet opsætningsguide.

Hvad kommer efter sub-1 B modellerne

At reducere antallet af parametre er én måde at gøre en VLA billig på og ikke nødvendigvis den vindende. OpenVLA-OFT (arXiv 2502.19645) bevarer 7 B rygraden og ændrer kun, hvordan handlinger afkodes, hvilket rapporterer en 26x stigning i gennemløb for handlinggenerering og LIBERO stiger fra 76.5 til 97.1 procent. BitVLA (arXiv 2506.07530) gør hver vægt af en 1-bit BitNet b1.58 2B4T rygrad ternær, hvilket rapporterer 11.0x mindre hukommelse og 4.4x lavere end-to-end latenstid, mens den matcher fuldpræcisions OpenVLA-OFT. X-VLA-0.9B (arXiv 2510.10274) ligger på 1 B linjen med flow matching.

Den fælles tråd: handlingsdekoderen, ikke sprogmodellen, er der, hvor latenstiden ligger. Spørg, hvordan en politik udsender handlinger, før du spørger, hvor mange parametre den har. arenaen har 85 modeller og 332 resultater, hver linket til sin kilde; der er en bredere oversigt i vores VLA introduktion.