Kleine VLA Modellen: TinyVLA, SmolVLA en het Sub-1B Geval

Bijna elk visie-taal-actie model waarover geschreven wordt, gaat uit van een datacentrumkaart. OpenVLA is 7 B parameters. GR00T N1.7 en Pi0.5 zijn ongeveer 3 B en vereisen een A100 80 GB om te fine-tunen. Als de kaart op je bureau een 4090 is, dan is die klasse van modellen buiten bereik.

Twee papers beweren dat je het niet nodig hebt. TinyVLA (arXiv 2409.12514, geaccepteerd door IEEE Robotics and Automation Letters in februari 2025) bouwt een VLA op uit een 400 M tot 1.3 B backbone plus een diffusie-actiehoofd. SmolVLA (arXiv 2506.01844, ingediend op 2 juni 2025) levert 450 M parameters met open gewichten, open data en een script dat draait op één consumentenkaart. Hier is wat beide maten, en waar het argument voor modellen onder 1 B niet langer opgaat.

Wat daadwerkelijk telt als een kleine VLA

Het aantal parameters op een modelkaart is niet één getal. Het kan het totale aantal gewichten, gewichten geladen tijdens inferentie, of gewichten die gradiënten ontvangen tijdens fine-tuning. TinyVLA rapporteert beide, en het verschil is groot: TinyVLA-H is 1.3 B totaal maar 143 M trainbaar, omdat de vision tower en het grootste deel van het taalmodel bevroren blijven terwijl LoRA-adapters en de action head bewegen. Het artikel schat het trainbare aandeel op ongeveer 5 procent.

Twee rijen zijn het bespreken waard. ACT met ongeveer 80 M is kleiner dan al het andere hier, maar heeft geen taalmodel, dus het is geen VLA: het leert één taak en kan niet worden verteld om een andere te doen. Octo-Small met 27 M wordt geconditioneerd via een T5-Base tekst-encoder, niet een LLM-backbone. Goede baselines, maar geen van beide biedt de instructievolging die het label impliceert.

TinyVLA: de snelheid komt van de head, niet van de backbone

De voor de hand liggende interpretatie is dat ze het taalmodel kleiner hebben gemaakt, waardoor het sneller werd. De ablatie in het artikel zegt iets anders. Het vervangen van OpenVLA's 7 B backbone door een van ongeveer 1 B verminderde de voorspelling per actie van 292 ms naar 140 ms, een winst van 2x. TinyVLA-H, met een vergelijkbaar aantal parameters, draait op 14 ms op dezelfde kaart. De andere 10x komt van de action head.

OpenVLA zendt acties uit als gediscretiseerde tokens via de taalmodel head, één per actiedimensie, autoregressief. TinyVLA voegt een diffusiedecoder toe die het hele stuk in één keer produceert. Tabel V toont de architectuur van TinyVLA-H en wisselt alleen de head, op dezelfde vijf echte-robot taken. Het is het duidelijkste bewijs in beide artikelen voor het argument dat flow matching beleidsregels maken, en de reden waarom Pi0 afstapte van token-decodering.

Wat TinyVLA scoorde

De bimanuële rij heeft een saaie verklaring die de paper zelf geeft: OpenVLA is voorgegetraind op Open X-Embodiment, dat volledig bestaat uit data van één arm, dus een actieruimte met twee armen valt buiten de distributie en scoort nul. De diffusion policy baseline verslaat TinyVLA-H op twee van die drie taken. Achtergrond in de Open X-Embodiment uiteenzetting.

De TinyVLA repo, per augustus 2026

De paper is goed. De code is een onderzoeksrelease. De repository is github.com/liyaxuanliyaxuan/TinyVLA; de README dateert de coderelease op 17 februari 2025 en de laatste commit is van 11 maart 2025. Prima voor het reproduceren van een paper, een probleem als je een onderhouden bibliotheek wilde.

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 leest ook geen LeRobot datasets. Het formaat is ACT-stijl HDF5: action, language_raw, en een observatiegroep met multi-view beelden, joint_positions, qpos en qvel. De repository levert data_utils/rlds_to_h5py.py voor RLDS-input, en elke taak wordt handmatig geregistreerd in aloha_scripts/constants.py met zijn dataset_dir, episode_len en camera_names. Als uw afleveringen afkomstig zijn van lerobot of de desktopclient, bent u verantwoordelijk voor de conversie.

# 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 gaat uit van een node met acht kaarten. Stel dit in op 1 en verlaag de batchgrootte tot ver onder de 32. Er wordt geen variant voor één GPU upstream geleverd, dus de opdracht kan niet letterlijk worden uitgevoerd op een 4090.
• --deepspeed scripts/zero2.json verwijst naar een bestand dat zich niet in de hoofdmap scripts bevindt. De DeepSpeed-configuraties worden geleverd in llava-pythia/scripts/zero2.json. Corrigeer het pad vóór uw eerste uitvoering.
• De README vereist dat de naam van de uitvoermap llava_pythia bevat, plus lora als LoRA is ingeschakeld.
• De backbone is een aparte download: lesjie/Llava-Pythia-400M, -700M of -1.3B. Er is geen enkel basischeckpoint waar je een beleid op richt, zoals je dat doet bij lerobot/smolvla_base.

SmolVLA: het sub-1 B-model dat u vanmiddag kunt uitvoeren

SmolVLA maakt hetzelfde argument binnen een onderhouden bibliotheek. Het heeft 450 M parameters op een SmolVLM2-500M-Video-Instruct backbone, en de efficiëntie komt voort uit instellingen die u kunt aflezen uit configuration_smolvla.py in plaats van uit een bewering over klein zijn.

Voor de pretraining werden 481 community LeRobot datasets, 22.9 K afleveringen en 10.6 M frames gebruikt op 4 GPU's, 200000 stappen met een globale batchgrootte van 256; het artikel schat het hele project op ongeveer 30 K GPU-uren. Een getal om op te letten: de Hugging Face lanceerblog vermeldt 487 samengestelde datasets, terwijl de tabel in het artikel 481 vermeldt. We gebruiken het cijfer uit het artikel en signaleren de discrepantie.

Eén toeval helpt: de Meta-World tabel van het SmolVLA-artikel bevat de eigen gepubliceerde cijfers van TinyVLA als basislijn, dus voor één keer staan beide modellen in één tabel, SmolVLA-0.45B op 57.3 tegen TinyVLA-H op 31.6. Het meldt ook dat SmolVLA ongeveer 40 procent sneller traint dan Pi0 op 6x minder geheugen. Dit alles komt van de SmolVLA-auteurs; de arena-vermelding linkt elke waarde aan de bron.

Waar SmolVLA zijn tijd aan besteedt

AY-Robots vermeldt SmolVLA op 245 ms per actiestap en ACT op 20 ms in de beleidscatalogus. TinyVLA rapporteert 14 ms per actievoorspelling. Deze cijfers zijn niet vergelijkbaar, en ze behandelen alsof ze dat wel zijn, is de meest voorkomende fout in dit onderwerp: sommigen meten één forward pass, sommigen verdelen die pass over een chunk zodra actie-chunking het amortiseert.

• SmolVLA zendt 50 acties uit per forward pass en voert alle 50 uit. Bij de 30 fps die het artikel gebruikt op echte robots, dekt één inferentie ongeveer 1.7 seconden beweging.
• Asynchrone inferentie berekent de volgende chunk terwijl de huidige nog wordt uitgevoerd: 9.7 s gemiddelde taakvoltooiing tegen 13.75 s synchroon, ruwweg 30 procent sneller, en 19 pick-and-place cycli in een vast venster van 60 seconden tegen 9.
• Succespercentages waren vergelijkbaar in plaats van beter, 78.3 synchroon tegen 73.3 asynchroon. Async koopt doorvoer, geen nauwkeurigheid.
• Chunking verbergt rekenlatentie, niet netwerklatentie, en het maakt het beleid minder reactief omdat het zich heeft vastgelegd op 50 acties.

Finetunen van SmolVLA op één consumentenkaart

Het handmatige pad, op lerobot 0.6.1, de huidige PyPI-release per 23 augustus 2026. Alles hieronder komt uit de Hugging Face lerobot SmolVLA documentatie, op dezelfde dag opgehaald; de begeleide versie is vriendelijker.

1. 1
   Installeer lerobot met de smolvla extra

   De SmolVLA-afhankelijkheden zijn een optionele extra, geen onderdeel van de basisinstallatie. Installeren zonder en je dan afvragen waarom het beleidstype onbekend is, is een veelvoorkomend half uur verspild.

   bash

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

2. 2
   Verkrijg een dataset met voldoende afleveringen

   De documentatie beveelt ongeveer 50 afleveringen aan en stelt dat dezelfde taak met 25 niet voldoende was. AY-Robots stelt het minimum op 30. Neem je eigen op, of begin vanuit de datasetmap.

   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 de fine-tune

   Het commando uit de lerobot-handleiding, ongewijzigd. De documentatie schat 20000 stappen op ongeveer 4 uur op één A100. Op een 24 GB kaart, verwacht langer en meet het.

   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
   Verlaag de batchgrootte totdat het past

   batch_size=64 is een gedocumenteerd voorbeeld, geen belofte over je kaart. De documentatie adviseert klein te beginnen en te verhogen zolang de laadtijden kort blijven.

   bash

   lerobot-train --help

5. 5
   Rol het checkpoint uit op de arm

   Dezelfde bibliotheek, één commando. De real-time chunking flags zijn uitcommentarieerd in de documentatie en zijn degenen die je moet gebruiken op hardware met laag vermogen.

   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

Twee manieren om een kleine VLA op een arm te krijgen

Wanneer een klein model de verkeerde keuze is

Beide papers zijn hier voorzichtiger dan de samenvattingen. TinyVLA's faalanalyse is specifiek: de 0.4 B variant faalde drie keer door de instructie verkeerd te lezen, wat de auteurs toeschrijven aan beperkt taalbegrip in de kleinere VLM, en die modus verdween bij 1.3 B. SmolVLA toont dezelfde curve vanaf de andere kant: de 2.25 B versie van de identieke architectuur scoort 88.75 op LIBERO en 68.24 op Meta-World tegenover 87.3 en 57.3 voor het 0.45 B model.

De vergelijking die de moeite waard is, is niet TinyVLA tegen SmolVLA. Het is SmolVLA tegen ACT op je eigen taak, en de SmolVLA paper is het argument waarom. Getraind als single-task zonder robotica pretraining, behaalde SmolVLA gemiddeld 40.0 over drie SO-100 taken waar single-task ACT 48.3 behaalde. Wat het naar 78.3 tilt, is community pretraining plus multi-task training, niet de architectuur alleen. Op de SO-101 lego taak, beide single-task, wint SmolVLA wel: 90 tegen 70 in distributie. Dan SmolVLA tegen Pi0.5 als het budget het toelaat.

Een beslissingstabel waarop u kunt handelen

Voor de laatste rij, de live arm streamt een fysieke SO-100 die je vanuit de browser kunt besturen zonder account, en de drie manieren om te beginnen behandelt de rest. De SO-100 is hier de referentiearm, ruwweg 110 tot 150 EUR aan onderdelen, met een volledige installatiegids.

Wat komt er na de sub-1 B modellen

Het verkleinen van het aantal parameters is één manier om een VLA goedkoop te maken en niet per se de winnende. OpenVLA-OFT (arXiv 2502.19645) behoudt de 7 B backbone en verandert alleen hoe acties worden gedecodeerd, wat een 26x toename in actiegeneratiedoorvoer en een stijging van LIBERO van 76.5 naar 97.1 procent rapporteert. BitVLA (arXiv 2506.07530) maakt elk gewicht van een 1-bit BitNet b1.58 2B4T backbone ternair, wat 11.0x minder geheugen en 4.4x lagere end-to-end latentie rapporteert, terwijl het overeenkomt met full-precision OpenVLA-OFT. X-VLA-0.9B (arXiv 2510.10274) bevindt zich op de 1 B lijn met flow matching.

De rode draad: de actiedecoder, niet het taalmodel, is waar de latentie zit. Vraag hoe een beleid acties uitzendt voordat je vraagt hoeveel parameters het heeft. De arena heeft 85 modellen en 332 resultaten, elk gekoppeld aan de bron; er is een breder overzicht in onze VLA introductie.