Små VLA-modeller: TinyVLA, SmolVLA och fallet under 1 miljard parametrar

Nästan varje syn-språk-handlingsmodell som det skrivs om förutsätter ett datacentrumkort. OpenVLA har 7 B parametrar. GR00T N1.7 och Pi0.5 är runt 3 B och kräver ett A100 80 GB för finjustering. Om kortet på ditt skrivbord är ett 4090, är den klassen av modeller utom räckhåll.

Två artiklar hävdar att du inte behöver det. TinyVLA (arXiv 2409.12514, accepterad av IEEE Robotics and Automation Letters i februari 2025) bygger en VLA från en 400 M till 1.3 B ryggrad plus ett diffusionshandlingshuvud. SmolVLA (arXiv 2506.01844, inskickad 2 juni 2025) levereras med 450 M parametrar med öppna vikter, öppen data och ett skript som körs på ett konsumentkort. Här är vad båda mätte, och var argumentet om under 1 B slutar hålla.

Vad som faktiskt räknas som en liten VLA

Antalet parametrar på ett modellkort är inte ett enda nummer. Det kan avse totala vikter, vikter som laddas vid inferens, eller vikter som tar emot gradienter under . TinyVLA rapporterar båda, och skillnaden är stor: TinyVLA-H är totalt 1,3 B men 143 M träningsbara, eftersom visionstornet och större delen av språkmodellen förblir frysta medan LoRA-adaptrar och actionhuvudet rör sig. Artikeln anger den träningsbara andelen till cirka 5 procent.

Två rader är värda att diskutera. på ungefär 80 M är mindre än allt annat här men har ingen språkmodell, så det är inte en VLA: den lär sig en uppgift och kan inte instrueras att göra en annan. på 27 M är villkorad via en T5-Base textkodare, inte en LLM-grundmodell. Bra baslinjer, men ingen av dem ger dig den instruktionsföljning som etiketten antyder.

TinyVLA: hastigheten kommer från huvudet, inte ryggraden

Den uppenbara tolkningen är att de gjorde språkmodellen mindre, så den blev snabbare. Artikelns ablation säger något annat. Att byta ut OpenVLA:s 7 B ryggrad mot en på ungefär 1 B minskade förutsägelsen per åtgärd från 292 ms till 140 ms, en 2x förbättring. TinyVLA-H, med ett jämförbart antal parametrar, körs på 14 ms på samma kort. Den andra 10x är åtgärdshuvudet.

OpenVLA avger åtgärder som diskretiserade tokens genom språkmodellhuvudet, en per åtgärdsdimension, autoregressivt. TinyVLA kopplar en diffusionsavkodare som producerar hela klumpen i ett svep. Tabell V visar arkitekturen för TinyVLA-H och byter endast huvudet, på samma fem verkliga robotuppgifter. Det är det tydligaste beviset i någon av artiklarna för argumentet flow matching policyer framför, och anledningen till att Pi0 gick bort från tokenavkodning.

Vad TinyVLA uppnådde

Den bimanuala raden har en tråkig förklaring som artikeln själv ger: OpenVLA är förtränad på Open X-Embodiment, som helt består av data från enarmade robotar, så ett tvåarmat aktionsutrymme är utanför distributionen och får noll poäng. Baslinjen för diffusionspolicy slår TinyVLA-H på två av dessa tre uppgifter. Bakgrund i sammanfattningen av Open X-Embodiment.

TinyVLA-repot, per augusti 2026

Artikeln är bra. Koden är en forskningsrelease. Repot är github.com/liyaxuanliyaxuan/TinyVLA; dess README daterar kodreleasen till 17 februari 2025 och den senaste committen är 11 mars 2025. Bra för att reproducera en artikel, ett problem om du ville ha ett underhållet 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 inte heller LeRobot-dataset. Dess format är ACT-stil HDF5: action, language_raw, och en observationsgrupp med flervybilder, joint_positions, qpos och qvel. Arkivet levereras med data_utils/rlds_to_h5py.py för RLDS-input, och varje uppgift registreras manuellt i aloha_scripts/constants.py med dess dataset_dir, episode_len och camera_names. Om dina episoder kom från lerobot eller skrivbordsklienten, äger 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 nod med åtta kort. Ställ in den på 1 och sänk batchstorleken långt under 32. Ingen variant för enstaka GPU levereras uppströms, så kommandot kan inte köras ordagrant på en 4090.
• --deepspeed scripts/zero2.json pekar på en fil som inte finns i den översta scripts-katalogen. DeepSpeed-konfigurationerna finns på llava-pythia/scripts/zero2.json. Korrigera sökvägen före din första körning.
• README kräver att namnet på utdatakatalogen innehåller llava_pythia, plus lora om LoRA är aktiverat.
• Ryggraden är en separat nedladdning: lesjie/Llava-Pythia-400M, -700M eller -1.3B. Det finns ingen enskild bas-checkpoint som du pekar en policy mot på samma sätt som du pekar mot lerobot/smolvla_base.

SmolVLA: modellen under 1 miljard parametrar som du kan köra i eftermiddag

SmolVLA framför samma argument inom ett underhållet bibliotek. Den har 450 miljoner parametrar på en SmolVLM2-500M-Video-Instruct-ryggrad, och effektiviteten kommer från inställningar som du kan läsa ut ur configuration_smolvla.py snarare än från ett påstående om att vara liten.

Förträningen använde 481 LeRobot-community-datauppsättningar, 22.9 K episoder och 10.6 M ramar på 4 GPU:er, 200000 steg med en global batchstorlek på 256; artikeln uppskattar hela projektet till cirka 30 K GPU-timmar. En siffra att notera: Hugging Face lanseringsblogg anger 487 kurerade datauppsättningar där artikelns tabell anger 481. Vi använder artikelns siffra och noterar avvikelsen.

En slump hjälper: SmolVLA-artikelns Meta-World-tabell innehåller TinyVLAs egna publicerade siffror som baslinje, så för en gångs skull finns båda modellerna i en tabell, SmolVLA-0.45B på 57.3 mot TinyVLA-H på 31.6. Den rapporterar också att SmolVLA-träningen är cirka 40 procent snabbare än Pi0 med 6 gånger mindre minne. Allt detta kommer från SmolVLA-författarna; arena-posten länkar varje värde till dess källa.

Var SmolVLA tillbringar sin tid

AY-Robots listar SmolVLA till 245 ms per åtgärdssteg och ACT till 20 ms i policykatalogen. TinyVLA rapporterar 14 ms per åtgärdsförutsägelse. Dessa siffror är inte jämförbara, och att behandla dem som om de vore det är det vanligaste misstaget i detta ämne: vissa mäter en framåtkörning, andra delar upp den körningen över en chunk när åtgärdschunking amorterar den.

• SmolVLA genererar 50 åtgärder per framåtkörning och utför alla 50. Vid de 30 fps som artikeln använder på riktiga robotar täcker en inferens cirka 1.7 sekunders rörelse.
• Asynkron inferens beräknar nästa chunk medan den nuvarande fortfarande utförs: 9.7 s genomsnittlig uppgiftskomplettering mot 13.75 s synkron, ungefär 30 procent snabbare, och 19 plock-och-placera-cykler i ett fast 60-sekundersfönster mot 9.
• Framgångsfrekvenserna var jämförbara snarare än bättre, 78.3 synkron mot 73.3 asynkron. Asynkronitet köper genomströmning, inte noggrannhet.
• Chunking döljer beräkningslatens, inte nätverkslatens, och det gör policyn mindre reaktiv eftersom den är bunden till 50 åtgärder.

Finjustering av SmolVLA på ett konsumentgrafikkort

Den manuella vägen, på lerobot 0.6.1, den nuvarande PyPI-releasen per den 23 augusti 2026. Allt nedan kommer från Hugging Face lerobot SmolVLA-dokumentationen, hämtad samma dag; den guidade versionen är skonsammare.

1. 1
   Installera lerobot med smolvla-tillägget

   SmolVLA-beroendena är ett valfritt tillägg, inte en del av basinstallationen. Att installera utan det och sedan undra varför policytypen är okänd är en vanlig halvtimme som går förlorad.

   bash

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

2. 2
   Skaffa en datamängd med tillräckligt många episoder

   Dokumentationen rekommenderar cirka 50 episoder och anger att samma uppgift med 25 inte var tillräckligt. AY-Robots sätter minimigränsen till 30. Spela in dina egna, eller börja från datamängdskatalogen.

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

   Kommandot från lerobot-guiden, oförändrat. Dokumentationen anger 20000 steg till ungefär 4 timmar på ett A100. På ett 24 GB-kort, förvänta dig längre tid och mät 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
   Minska batchstorleken tills den passar

   batch_size=64 är ett dokumenterat exempel, inte ett löfte om ditt kort. Dokumentationen rekommenderar att börja smått och öka medan laddningstiderna förblir korta.

   bash

   lerobot-train --help

5. 5
   Rulla ut checkpointen på armen

   Samma bibliotek, ett kommando. Flaggorna för realtidschunking är kommenterade i dokumentationen och är de man ska använda på hårdvara med låg 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

Två sätt att få en liten VLA på en arm

När en liten modell är fel val

Båda artiklarna är mer noggranna här än vad sammanfattningarna är. TinyVLAs felanalys är specifik: 0,4 B-varianten misslyckades tre gånger genom att feltolka instruktionen, vilket författarna tillskriver begränsad språkförståelse i den mindre VLM:en, och det läget försvann vid 1,3 B. SmolVLA visar samma kurva från andra änden: 2,25 B-versionen av den identiska arkitekturen får 88,75 på LIBERO och 68,24 på Meta-World jämfört med 87,3 och 57,3 för 0,45 B-modellen.

Jämförelsen som är värd att göra är inte TinyVLA mot SmolVLA. Det är SmolVLA mot ACT på din egen uppgift, och SmolVLA-artikeln är argumentet för varför. Tränad för en enskild uppgift utan robotikförträning, fick SmolVLA i genomsnitt 40,0 över tre SO-100-uppgifter där enskild uppgift ACT uppnådde 48,3. Det som lyfter den till 78,3 är gemenskapsförträning plus fleruppgiftsträning, inte arkitekturen ensam. På SO-101 lego-uppgiften, båda enskilda uppgifter, vinner SmolVLA: 90 mot 70 i distribution. Sedan SmolVLA mot Pi0.5 om budgeten tillåter.

En beslutstabell du kan agera utifrån

För den sista raden, den levande armen strömmar en fysisk SO-100 som du kan styra från webbläsaren utan konto, och de tre sätten att komma igång täcker resten. SO-100 är referensarmen här, ungefär 110 till 150 EUR i delar, med en komplett installationsguide.

Vad kommer efter modellerna under 1 B

Att minska antalet parametrar är ett sätt att göra en VLA billig och inte uppenbart det vinnande. OpenVLA-OFT (arXiv 2502.19645) behåller 7 B-ryggraden och ändrar endast hur handlingar avkodas, vilket rapporterar en 26x ökning i genomströmning för handlingsgenerering och LIBERO som stiger från 76,5 till 97,1 procent. BitVLA (arXiv 2506.07530) gör varje vikt i en 1-bitars BitNet b1.58 2B4T-ryggrad ternär, vilket rapporterar 11,0x mindre minne och 4,4x lägre end-to-end-latens samtidigt som den matchar full-precision OpenVLA-OFT. X-VLA-0.9B (arXiv 2510.10274) ligger på 1 B-linjen med flödesmatchning.

Den gemensamma nämnaren: handlingsavkodaren, inte språkmodellen, är där latensen finns. Fråga hur en policy utför handlingar innan du frågar hur många parametrar den har. Arenan har 85 modeller och 332 resultat, var och en länkad till sin källa; det finns en bredare översikt i vår VLA-introduktion.