Modelli VLA Piccoli: TinyVLA, SmolVLA e il Caso Sotto 1 Miliardo di Parametri

Quasi ogni modello visione-linguaggio-azione di cui si scrive presuppone una scheda da data center. OpenVLA ha 7 miliardi di parametri. GR00T N1.7 e Pi0.5 sono circa 3 miliardi e richiedono una A100 da 80 GB per il fine-tuning. Se la scheda sulla tua scrivania è una 4090, quella classe di modelli è fuori portata.

Due articoli sostengono che non ne hai bisogno. TinyVLA (arXiv 2409.12514, accettato da IEEE Robotics and Automation Letters a febbraio 2025) costruisce un VLA da un backbone da 400 milioni a 1.3 miliardi più una testa d'azione a diffusione. SmolVLA (arXiv 2506.01844, sottomesso il 2 giugno 2025) distribuisce 450 milioni di parametri con pesi aperti, dati aperti e uno script che gira su una singola scheda consumer. Ecco cosa hanno misurato entrambi, e dove l'argomento del "sotto 1 miliardo" smette di reggere.

Cosa conta effettivamente come un VLA piccolo

Il conteggio dei parametri su una scheda modello non è un singolo numero. Può significare pesi totali, pesi caricati durante l'inferenza o pesi che ricevono gradienti durante . TinyVLA riporta entrambi, e il divario è ampio: TinyVLA-H è 1.3 B totale ma 143 M addestrabili, perché la torre di visione e la maggior parte del modello linguistico rimangono congelati mentre gli adattatori LoRA e la testa d'azione si muovono. L'articolo stima la quota addestrabili a circa il 5 percento.

Due righe meritano una discussione. a circa 80 M è più piccolo di tutto il resto qui ma non ha un modello linguistico, quindi non è un VLA: impara un compito e non gli si può dire di farne un altro. a 27 M è condizionato tramite un codificatore di testo T5-Base, non un backbone LLM. Buone baseline, nessuna delle due offre il rispetto delle istruzioni che l'etichetta implica.

TinyVLA: la velocità viene dalla testa, non dalla backbone

La lettura ovvia è che hanno reso il modello linguistico più piccolo, quindi è diventato più veloce. L'ablazione del paper dice il contrario. Sostituire la backbone da 7 B di OpenVLA con una da circa 1 B ha ridotto la previsione per azione da 292 ms a 140 ms, un guadagno di 2x. TinyVLA-H, con un numero di parametri comparabile, funziona a 14 ms sulla stessa scheda. L'altro 10x è la testa d'azione.

OpenVLA emette azioni come token discretizzati attraverso la testa del modello linguistico, uno per dimensione d'azione, in modo autoregressivo. TinyVLA allega un decodificatore a diffusione che produce l'intero blocco in un'unica soluzione. La Tabella V mostra l'architettura di TinyVLA-H e scambia solo la testa, sugli stessi cinque compiti di robot reali. È la prova più chiara in entrambi i paper per l'argomento flow matching che le politiche creano, e la ragione per cui Pi0 si è allontanato dalla decodifica dei token.

I punteggi di TinyVLA

La riga bimanuale ha una spiegazione noiosa che il paper stesso fornisce: OpenVLA è pre-addestrato su Open X-Embodiment, che consiste interamente in dati a braccio singolo, quindi uno spazio di azione a due braccia è fuori distribuzione e ottiene zero. La baseline della politica di diffusione batte TinyVLA-H su due di queste tre attività. Contesto in l'articolo su Open X-Embodiment.

Il repository TinyVLA, ad agosto 2026

Il paper è buono. Il codice è un rilascio di ricerca. Il repository è github.com/liyaxuanliyaxuan/TinyVLA; il suo README data il rilascio del codice al 17 febbraio 2025 e l'ultimo commit all'11 marzo 2025. Ottimo per riprodurre un paper, un problema se si desiderasse una libreria mantenuta.

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 inoltre non legge dataset LeRobot. Il suo formato è HDF5 in stile ACT: action, language_raw, e un gruppo di osservazioni con immagini multi-vista, joint_positions, qpos e qvel. Il repository include data_utils/rlds_to_h5py.py per l'input RLDS, e ogni task è registrato manualmente in aloha_scripts/constants.py con il suo dataset_dir, episode_len e camera_names. Se i tuoi episodi provengono da lerobot o dal client desktop, la conversione è a tuo carico.

# 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 presuppone un nodo a otto schede. Impostalo a 1 e riduci la dimensione del batch ben al di sotto di 32. Nessuna variante a singola GPU viene fornita upstream, quindi il comando non può essere eseguito alla lettera su una 4090.
• --deepspeed scripts/zero2.json punta a un file che non si trova nella directory scripts di primo livello. Le configurazioni DeepSpeed si trovano in llava-pythia/scripts/zero2.json. Correggi il percorso prima della tua prima esecuzione.
• Il README richiede che il nome della directory di output contenga llava_pythia, più lora se LoRA è abilitato.
• Il backbone è un download separato: lesjie/Llava-Pythia-400M, -700M o -1.3B. Non esiste un singolo checkpoint di base a cui puntare una policy nel modo in cui si punta a lerobot/smolvla_base.

SmolVLA: il modello sub-1 B che puoi eseguire questo pomeriggio

SmolVLA presenta lo stesso argomento all'interno di una libreria mantenuta. Ha 450 milioni di parametri su un backbone SmolVLM2-500M-Video-Instruct, e l'efficienza deriva dalle impostazioni che puoi leggere da configuration_smolvla.py piuttosto che da un'affermazione sull'essere piccolo.

Il pre-addestramento ha utilizzato 481 dataset LeRobot della community, 22,9 K episodi e 10,6 M frame su 4 GPU, 200000 passi con un batch globale di 256; il paper stima l'intero progetto a circa 30 K ore GPU. Un numero da tenere d'occhio: il blog di lancio di Hugging Face menziona 487 dataset curati, mentre la tabella del paper ne indica 481. Utilizziamo la cifra del paper e segnaliamo la discrepanza.

Un caso fortuito aiuta: la tabella Meta-World del paper SmolVLA riporta i numeri pubblicati di TinyVLA come baseline, quindi per una volta entrambi i modelli sono presenti in un'unica tabella, SmolVLA-0.45B a 57.3 contro TinyVLA-H a 31.6. Riporta anche che l'addestramento di SmolVLA è circa il 40 percento più veloce di Pi0 con 6 volte meno memoria. Tutto ciò proviene dagli autori di SmolVLA; l'voce dell'arena collega ogni valore alla sua fonte.

Dove SmolVLA impiega il suo tempo

AY-Robots elenca SmolVLA a 245 ms per passo d'azione e ACT a 20 ms nel catalogo delle policy. TinyVLA riporta 14 ms per previsione d'azione. Questi numeri non sono comparabili, e trattarli come se lo fossero è l'errore più comune in questo argomento: alcuni misurano un singolo passaggio in avanti, altri dividono quel passaggio su un chunk una volta che chunking delle azioni lo ammortizza.

• SmolVLA emette 50 azioni per passaggio in avanti ed esegue tutte le 50. Ai 30 fps che il paper utilizza su robot reali, un'inferenza copre circa 1.7 secondi di movimento.
• L'inferenza asincrona calcola il chunk successivo mentre quello corrente è ancora in esecuzione: 9.7 s di completamento medio del task contro 13.75 s sincroni, circa il 30 percento più veloce, e 19 cicli di pick-and-place in una finestra fissa di 60 secondi contro 9.
• I tassi di successo erano comparabili piuttosto che migliori, 78.3 sincroni contro 73.3 asincroni. L'asincronia acquista throughput, non accuratezza.
• Il chunking nasconde la latenza di calcolo, non la latenza di rete, e rende la policy meno reattiva perché è impegnata a 50 azioni.

Fine-tuning di SmolVLA su una scheda consumer

Il percorso manuale, su lerobot 0.6.1, la versione PyPI attuale al 23 agosto 2026. Tutto ciò che segue proviene dalla documentazione di Hugging Face lerobot SmolVLA, recuperata lo stesso giorno; la versione guidata è più delicata.

1. 1
   Installa lerobot con l'extra smolvla

   Le dipendenze di SmolVLA sono un extra opzionale, non fanno parte dell'installazione base. Installare senza di esse e poi chiedersi perché il tipo di policy sia sconosciuto è una comune mezz'ora persa.

   bash

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

2. 2
   Ottieni un dataset con abbastanza episodi

   La documentazione raccomanda circa 50 episodi e afferma che lo stesso compito con 25 non era sufficiente. AY-Robots imposta il minimo a 30. Registra i tuoi, o inizia dalla directory dei dataset.

   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
   Avvia il fine-tuning

   Il comando dalla guida di lerobot, non modificato. La documentazione stima 20000 passi in circa 4 ore su una A100. Su una scheda da 24 GB, aspettati tempi più lunghi e misurali.

   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
   Riduci la dimensione del batch finché non si adatta

   batch_size=64 è un esempio documentato, non una promessa riguardo alla tua scheda. La documentazione consiglia di iniziare con un valore piccolo e aumentarlo finché i tempi di caricamento rimangono brevi.

   bash

   lerobot-train --help

5. 5
   Distribuisci il checkpoint sul braccio

   Stessa libreria, un solo comando. I flag di chunking in tempo reale sono commentati nella documentazione e sono quelli da utilizzare su hardware a bassa potenza.

   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

Due modi per portare un piccolo VLA su un braccio

Quando un modello piccolo è la scelta sbagliata

Entrambi gli articoli sono più cauti qui rispetto ai riassunti. L'analisi dei fallimenti di TinyVLA è specifica: la variante da 0,4 B ha fallito tre volte interpretando erroneamente l'istruzione, cosa che gli autori attribuiscono a una comprensione linguistica limitata nel VLM più piccolo, e quella modalità è scomparsa a 1,3 B. SmolVLA mostra la stessa curva dall'altra estremità: la versione da 2,25 B dell'architettura identica ottiene 88,75 su LIBERO e 68,24 su Meta-World contro 87,3 e 57,3 per il modello da 0,45 B.

Il confronto che vale la pena fare non è TinyVLA contro SmolVLA. È SmolVLA contro ACT sul tuo compito, e l'articolo di SmolVLA è l'argomento del perché. Addestrato su un singolo compito senza pre-addestramento robotico, SmolVLA ha ottenuto una media di 40,0 su tre compiti SO-100 dove ACT su singolo compito ha gestito 48,3. Ciò che lo porta a 78,3 è il pre-addestramento della comunità più l'addestramento multi-task, non l'architettura da sola. Sul compito lego SO-101, entrambi su singolo compito, SmolVLA vince: 90 contro 70 in distribuzione. Poi SmolVLA contro Pi0.5 se il budget lo consente.

Una tabella decisionale su cui puoi agire

Per l'ultima riga, il braccio live trasmette un SO-100 fisico che puoi guidare dal browser senza un account, e i tre modi per iniziare copre il resto. Il SO-100 è il braccio di riferimento qui, circa 110-150 EUR in parti, con una guida completa all'installazione.

Cosa viene dopo i modelli sub-1 B

Ridurre il numero di parametri è un modo per rendere un VLA economico e non è ovviamente quello vincente. OpenVLA-OFT (arXiv 2502.19645) mantiene il backbone da 7 B e cambia solo il modo in cui le azioni vengono decodificate, riportando un aumento di 26x nel throughput di generazione delle azioni e LIBERO che sale dal 76.5 al 97.1 percento. BitVLA (arXiv 2506.07530) rende ternario ogni peso di un backbone BitNet b1.58 2B4T a 1 bit, riportando 11.0x meno memoria e 4.4x minore latenza end-to-end pur eguagliando OpenVLA-OFT a piena precisione. X-VLA-0.9B (arXiv 2510.10274) si posiziona sulla linea da 1 B con il flow matching.

Il filo conduttore: il decodificatore di azioni, non il modello linguistico, è dove risiede la latenza. Chiedi come una policy emette azioni prima di chiedere quanti parametri ha. L' arena ha 85 modelli e 332 risultati, ciascuno collegato alla sua fonte; c'è una panoramica più ampia nella nostra introduzione ai VLA.