Malé modely VLA: TinyVLA, SmolVLA a případ pod 1 miliardu parametrů

Téměř každý vizuálně-jazykově-akční model, o kterém se píše, předpokládá datacentrovou kartu. OpenVLA má 7 miliard parametrů. GR00T N1.7 a Pi0.5 mají kolem 3 miliard parametrů a pro jemné doladění vyžadují A100 80 GB. Pokud je karta na vašem stole 4090, tato třída modelů je mimo dosah.

Dva články tvrdí, že to nepotřebujete. TinyVLA (arXiv 2409.12514, přijato IEEE Robotics and Automation Letters v únoru 2025) staví VLA z páteřní sítě o velikosti 400 milionů až 1,3 miliardy parametrů plus difuzní akční hlavu. SmolVLA (arXiv 2506.01844, odesláno 2. června 2025) dodává 450 milionů parametrů s otevřenými váhami, otevřenými daty a skriptem, který běží na jedné spotřebitelské kartě. Zde je to, co oba změřily, a kde argument pod 1 miliardu parametrů přestává platit.

Co se skutečně počítá jako malý VLA

Počet parametrů na kartě modelu není jedno číslo. Může znamenat celkové váhy, váhy načtené při inferenci, nebo váhy, které přijímají gradienty během . TinyVLA uvádí obojí a rozdíl je velký: TinyVLA-H má celkem 1,3 B, ale 143 M je trénovatelných, protože vizuální věž a většina jazykového modelu zůstávají zmrazené, zatímco adaptéry LoRA a akční hlava se pohybují. Článek uvádí trénovatelný podíl na přibližně 5 procentech.

Dva řádky stojí za diskuzi. s přibližně 80 M je menší než vše ostatní zde, ale nemá jazykový model, takže to není VLA: učí se jeden úkol a nelze mu říct, aby dělal jiný. s 27 M je podmíněn textovým kodérem T5-Base, nikoli páteřní sítí LLM. Dobré základní modely, ani jeden vám nedá dodržování instrukcí, které název naznačuje.

TinyVLA: rychlost pochází z hlavy, ne z páteře

Zřejmý výklad je, že zmenšili jazykový model, a tak se zrychlil. Ablační studie v článku však říká něco jiného. Výměna 7B páteře OpenVLA za zhruba 1B snížila predikci na akci z 292 ms na 140 ms, což je 2x zrychlení. TinyVLA-H, srovnatelný počtem parametrů, běží na 14 ms na stejné kartě. Dalších 10x je akční hlava.

OpenVLA vydává akce jako diskretizované tokeny prostřednictvím hlavy jazykového modelu, jeden na dimenzi akce, autoregresivně. TinyVLA připojuje difuzní dekodér, který produkuje celý blok najednou. Tabulka V obsahuje architekturu TinyVLA-H a mění pouze hlavu, na stejných pěti úkolech reálného robota. Je to nejčistší důkaz v obou článcích pro argument, že politiky párování toků vytvářejí, a důvod, proč Pi0 se odklonilo od dekódování tokenů.

Co dosáhla TinyVLA

Bimanualní řádek má nudné vysvětlení, které si článek dává sám: OpenVLA je předtrénováno na Open X-Embodiment, které se skládá výhradně z dat pro jednu paži, takže akční prostor pro dvě paže je mimo distribuci a dosahuje nulového skóre. Základní linie difuzní politiky poráží TinyVLA-H na dvou ze tří těchto úkolů. Pozadí v článek o Open X-Embodiment.

Repozitář TinyVLA, k srpnu 2026

Článek je dobrý. Kód je výzkumný prototyp. Repozitář je github.com/liyaxuanliyaxuan/TinyVLA; jeho README datuje vydání kódu na 17. února 2025 a poslední commit je z 11. března 2025. Dobré pro reprodukci článku, problém, pokud byste chtěli udržovanou knihovnu.

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 také nečte datové sady LeRobot. Jeho formát je HDF5 ve stylu ACT: akce, language_raw a skupina pozorování s více pohledovými obrázky, joint_positions, qpos a qvel. Repozitář dodává data_utils/rlds_to_h5py.py pro vstup RLDS a každý úkol je ručně registrován v aloha_scripts/constants.py s jeho dataset_dir, episode_len a camera_names. Pokud vaše epizody pocházely z lerobot nebo z desktopového klienta, konverzi vlastníte vy.

# 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 předpokládá uzel s osmi kartami. Nastavte jej na 1 a snižte velikost dávky hluboko pod 32. Žádná varianta s jednou GPU není dodávána upstream, takže příkaz nelze spustit doslovně na 4090.
• --deepspeed scripts/zero2.json ukazuje na soubor, který není v adresáři scripts nejvyšší úrovně. Konfigurace DeepSpeed jsou dodávány v llava-pythia/scripts/zero2.json. Opravte cestu před prvním spuštěním.
• README vyžaduje, aby název výstupního adresáře obsahoval llava_pythia, plus lora, pokud je LoRA povolena.
• Páteř je samostatný ke stažení: lesjie/Llava-Pythia-400M, -700M or -1.3B. Neexistuje žádný jediný základní kontrolní bod, na který byste nasměrovali politiku tak, jako byste nasměrovali na lerobot/smolvla_base.

SmolVLA: model pod 1 B, který můžete spustit dnes odpoledne

SmolVLA předkládá stejný argument uvnitř udržované knihovny. Má 450 M parametrů na páteři SmolVLM2-500M-Video-Instruct a efektivita pochází z nastavení, která si můžete přečíst z configuration_smolvla.py, spíše než z tvrzení o tom, že je malý.

Předtrénink využil 481 komunitních datasetů LeRobot, 22,9 tisíc epizod a 10,6 milionů snímků na 4 GPU, 200000 kroků s globální dávkou 256; článek odhaduje celý projekt na přibližně 30 tisíc GPU hodin. Jedno číslo k pozornosti: blog Hugging Face k uvedení uvádí 487 kurátorovaných datasetů, zatímco tabulka v článku uvádí 481. Používáme údaj z článku a upozorňujeme na nesoulad.

Jedna náhoda pomáhá: tabulka Meta-World v článku SmolVLA uvádí vlastní publikovaná čísla TinyVLA jako základ, takže poprvé oba modely sedí v jedné tabulce, SmolVLA-0.45B na 57.3 proti TinyVLA-H na 31.6. Také uvádí, že trénink SmolVLA je přibližně o 40 procent rychlejší než Pi0 na 6x menší paměti. Vše pochází od autorů SmolVLA; záznam v aréně odkazuje každou hodnotu na její zdroj.

Kde SmolVLA tráví svůj čas

AY-Robots uvádí SmolVLA na 245 ms na krok akce a ACT na 20 ms v katalogu politik. TinyVLA uvádí 14 ms na predikci akce. Tato čísla nejsou srovnatelná a považovat je za srovnatelná je nejčastější chybou v tomto tématu: někteří měří jeden průchod vpřed, někteří tento průchod rozdělí napříč blokem, jakmile rozdělení akcí na bloky to amortizuje.

• SmolVLA vydává 50 akcí na jeden průchod vpřed a provádí všech 50. Při 30 snímcích za sekundu, které článek používá na skutečných robotech, pokrývá jedna inference přibližně 1.7 sekundy pohybu.
• Asynchronní inference počítá další blok, zatímco aktuální se stále provádí: průměrné dokončení úkolu 9.7 s oproti 13.75 s synchronnímu, zhruba o 30 procent rychlejší, a 19 cyklů pick-and-place v pevném 60sekundovém okně oproti 9.
• Míra úspěšnosti byla spíše srovnatelná než lepší, 78.3 synchronní oproti 73.3 asynchronní. Asynchronní režim zvyšuje propustnost, nikoli přesnost.
• Rozdělení na bloky skrývá latenci výpočtů, nikoli latenci sítě, a činí politiku méně reaktivní, protože je vázána na 50 akcí.

Jemné ladění SmolVLA na jedné spotřebitelské kartě

Manuální cesta, na lerobot 0.6.1, aktuální vydání PyPI k 23. srpnu 2026. Vše níže pochází z dokumentace Hugging Face lerobot SmolVLA, stažené tentýž den; vedená verze je šetrnější.

1. 1
   Nainstalujte lerobot s doplňkem smolvla

   Závislosti SmolVLA jsou volitelným doplňkem, nejsou součástí základní instalace. Instalace bez nich a následné přemýšlení, proč je typ politiky neznámý, je běžná ztráta půl hodiny.

   bash

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

2. 2
   Získejte datovou sadu s dostatečným počtem epizod

   Dokumentace doporučuje kolem 50 epizod a uvádí, že stejný úkol s 25 epizodami nestačil. AY-Robots stanovuje minimum na 30. Nahrajte si vlastní, nebo začněte z adresáře datových sad.

   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
   Spusťte doladění

   Příkaz z průvodce lerobot, neupravený. Dokumentace uvádí 20000 kroků na přibližně 4 hodiny na jedné A100. Na 24 GB kartě očekávejte delší dobu a změřte ji.

   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
   Snižte velikost dávky, dokud se nevejde

   batch_size=64 je zdokumentovaný příklad, nikoli slib ohledně vaší karty. Dokumentace doporučuje začít s malou hodnotou a zvyšovat ji, dokud zůstávají doby načítání krátké.

   bash

   lerobot-train --help

5. 5
   Nasaďte checkpoint na rameno

   Stejná knihovna, jeden příkaz. Příznaky pro chunking v reálném čase jsou v dokumentaci zakomentovány a jsou to ty, po kterých sáhnete na hardwaru s nízkým výkonem.

   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

Dva způsoby, jak dostat malý VLA na rameno

Kdy je malý model špatnou volbou

Oba články jsou zde opatrnější než jejich shrnutí. Analýza selhání TinyVLA je specifická: varianta 0.4 B selhala třikrát špatným přečtením instrukce, což autoři připisují omezenému porozumění jazyka u menšího VLM, a tento režim zmizel u 1.3 B. SmolVLA ukazuje stejnou křivku z druhého konce: verze 2.25 B identické architektury dosahuje skóre 88.75 na LIBERO a 68.24 na Meta-World oproti 87.3 a 57.3 pro model 0.45 B.

Srovnání, které stojí za to provést, není TinyVLA proti SmolVLA. Je to SmolVLA proti ACT na vašem vlastním úkolu, a článek o SmolVLA je argumentem proč. Trénovaný na jedné úloze bez předtrénování v robotice, SmolVLA dosáhl průměru 40.0 napříč třemi úlohami SO-100, kde jednoúlohové ACT dosáhlo 48.3. Co ho pozvedá na 78.3, je komunitní předtrénování plus víceúlohové trénování, nikoli samotná architektura. Na úloze SO-101 s legem, obě jednoúlohové, SmolVLA skutečně vítězí: 90 proti 70 v distribuci. Poté SmolVLA proti Pi0.5 pokud to rozpočet dovolí.

Rozhodovací tabulka, podle které můžete jednat

Pro poslední řádek, živé rameno streamuje fyzický SO-100, který můžete ovládat z prohlížeče bez účtu, a tři způsoby, jak začít pokrývají zbytek. SO-100 je zde referenční rameno, zhruba 110 až 150 EUR v dílech, s kompletním průvodcem nastavením.

Co následuje po modelech pod 1 B

Zmenšování počtu parametrů je jedním ze způsobů, jak zlevnit VLA, a není to zjevně ten vítězný. OpenVLA-OFT (arXiv 2502.19645) si zachovává 7 B páteř a mění pouze způsob dekódování akcí, přičemž uvádí 26násobné zvýšení propustnosti generování akcí a nárůst LIBERO ze 76,5 na 97,1 procenta. BitVLA (arXiv 2506.07530) převádí každou váhu 1bitové páteře BitNet b1.58 2B4T na ternární, přičemž uvádí 11,0x menší paměť a 4,4x nižší end-to-end latenci při zachování přesnosti OpenVLA-OFT. X-VLA-0.9B (arXiv 2510.10274) se nachází na hranici 1 B s flow matching.

Společná nit: dekodér akcí, nikoli jazykový model, je místem, kde se skrývá latence. Zeptejte se, jak politika vydává akce, než se zeptáte, kolik má parametrů. Aréna obsahuje 85 modelů a 332 výsledků, každý s odkazem na svůj zdroj; širší přehled naleznete v našem úvodu do VLA.