Come Addestrare SmolVLA su una GPU da 24 GB (lerobot 0.6.1)

La maggior parte delle persone che desiderano un modello di azione linguaggio-visione su un braccio reale si fermano alla linea hardware. GR00T N1.7 e Pi0.5 sono circa tre miliardi di parametri ciascuno e richiedono una A100 da 80 GB o una H100. Se possiedi un PC da gaming con una RTX 4090, quella è la fine della strada. SmolVLA è l'eccezione: 450 M parametri, all'interno di LeRobot, costruito per il fine-tuning su una singola scheda consumer e per il servizio da una CPU.

Il percorso manuale prima: installa lerobot, scarica il checkpoint lerobot/smolvla_base, esegui il comando reale, leggi l'esecuzione mentre avviene. Poi il percorso della piattaforma, e dove non aiuta.

Cosa è SmolVLA, in numeri che puoi verificare

SmolVLA è una corrispondenza di flusso politica integrata in un piccolo modello linguistico visivo. L'architettura di base è SmolVLM2-500M-Video-Instruct; il documento mantiene solo i primi 16 strati del suo modello linguistico, limita ogni frame della telecamera a 64 token visivi con un pixel shuffle invece della tassellatura dell'immagine, e intercala l'attenzione incrociata con uno strato di auto-attenzione ogni secondo blocco. Il costo di inferenza è stato un vincolo di progettazione, non un ripensamento.

I benchmark sono il motivo per cui le persone si interessano a un modello da 450 M. Su LIBERO, ottiene una media dell'87.3 percento contro il 76.5 per OpenVLA a 7 B e l'86.0 per un Pi0 pre-addestrato per la robotica a 3.3 B; su Meta-World, 57.3 contro 47.9. Su hardware SO-100 reale, l'addestramento multi-task fornisce il 75 percento su pick and place, il 90 su stacking, il 70 su sorting, con una media del 78.3, dove ACT addestrato per compito ha ottenuto una media del 48.3. Le stesse righe si trovano accanto a ogni VLA pubblicato nella voce dell'arena SmolVLA e nel confronto ACT contro SmolVLA.

Perché una scheda da 24 GB è la scelta giusta per la prima esecuzione

LeRobot fornisce una guida al dimensionamento del calcolo, la pagina più utile nel repository per questo scopo. Raggruppa le policy per dimensione del backbone e fornisce un limite di VRAM per gruppo, misurato con una dimensione del batch di 8 e AdamW, l'impostazione predefinita di lerobot. Lo stato dell'ottimizzatore da solo aggiunge dal 30 al 100 percento rispetto a un semplice passaggio forward e backward, quindi queste non sono cifre relative solo ai pesi.

Dieci a sedici gigabyte con batch 8 è l'argomento: una scheda da 24 GB si adatta a questo più il dataloader. AY-Robots posiziona SmolVLA sulla RTX 4090 o su qualsiasi scheda da 24 GB, minimo 30 episodi, LeRobot v3.0 dati, 245 ms per passo d'azione. Noleggiata, sono da 2 a 5 ore a 0.30 a 0.60 USD all'ora, circa da 1 a 3 USD per una fine-tuning esecuzione, contro 4 a 12 USD sul livello da 80 GB che GR00T e Pi0.5 richiedono (pricing). Un'esecuzione fallita di SmolVLA è un caffè; un'esecuzione fallita di GR00T, un pranzo.

Passo 0: il dataset decide l'esecuzione, non i flag

Niente di quanto segue ha importanza se la registrazione è scadente. La pagina LeRobot SmolVLA è chiara: il dataset di riferimento era di 50 episodi distribuiti su 5 posizioni del cubo, 10 per posizione, e lo stesso compito con 25 episodi ha avuto prestazioni scarse. La ripetizione per variazione generalizza, il conteggio grezzo degli episodi no. Non ne hai mai registrato uno? Inizia da registra il tuo primo dataset, con il client desktop, che scrive il formato LeRobot da una sessione di teleoperazione, o prendine uno in prestito dalla directory dei dataset.

• Almeno 30 episodi su AY-Robots, circa 50 per la ricetta di riferimento LeRobot.
• Ogni variazione che ti aspetti al rollout, ripetuta più volte.
• Una stringa di attività, scritta in modo identico al momento della registrazione e del rollout. Il modello è condizionato da quel testo.
• Telecamere fisse. Una telecamera spostata tra la registrazione e il rollout è la ragione più comune per cui una curva di perdita pulita produce un braccio immobile.
• Una variazione 'held-out' su cui non hai mai addestrato, in modo da avere qualcosa di onesto contro cui testare.

# v2.1 -> v3.0: aggregates per-episode files into shards and writes the episode offsets
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=${HF_USER}/so100_pick_place

Maggiori informazioni su questo in come raccogliere dati di addestramento VLA di alta qualità. La versione breve: da 30 a 50 episodi puliti di un'unica attività con variazione intenzionale battono 200 episodi sciatto di tre, con un margine che nessun iperparametro può colmare.

Installa lerobot 0.6.1

# LeRobot needs Python 3.12 or newer as of 0.6.x
conda create -y -n lerobot python=3.12
conda activate lerobot

# TorchCodec decodes the dataset videos and wants ffmpeg
conda install ffmpeg -c conda-forge

# Base package is deliberately thin; extras pull the rest
pip install 'lerobot[smolvla,training,core_scripts]'

# Sanity check: prints the lerobot version, the GPU torch sees, and the console scripts you got
lerobot-info

L'installazione base lerobot, è leggera e nasconde dipendenze pesanti dietro gli extra: smolvla aggiunge transformers, num2words e accelerate, training lo stack del dataset e wandb, core_scripts le dipendenze hardware e di visualizzazione. Su Linux il percorso di installazione decide anche il tuo wheel CUDA: il default PyPI è un wheel cu130 con un driver minimo di 580.65, quindi su un driver più vecchio installa prima torch dall'indice cu128, poi lerobot.

L'esecuzione dell'addestramento, comando per comando

1. 1
   Autenticarsi all'Hub

   Il checkpoint di base proviene dall'Hub, e probabilmente anche il tuo dataset.

   bash

   hf auth login

2. 2
   Leggere le opzioni una volta

   Ogni campo della configurazione della pipeline e della policy è un flag. Dagli una scorsa prima di approfondire il codice sorgente.

   bash

   lerobot-train --help

3. 3
   Avviare il fine-tuning

   L'esempio della documentazione esegue un batch di 64 su una singola A100; l'ancora della guida al calcolo per A100 da 40 GB è un batch di 16, e 8 è l'equivalente per 24 GB. Nessun flag scheduler qui di proposito, vedi sotto.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/so100_pick_place \
     --batch_size=8 \
     --steps=20000 \
     --save_freq=2000 \
     --log_freq=200 \
     --seed=1000 \
     --output_dir=outputs/train/smolvla_pick_place \
     --job_name=smolvla_pick_place \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   Leggere la riga di log, non solo la perdita

   Ogni --log_freq passi, lerobot stampa loss, grdn, lr, updt_s, data_s, smp/s e, su CUDA, mem_gb. mem_gb indica se il batch si adatta, lr se lo schedule sta decadendo, e data_s che si avvicina a updt_s significa che il dataloader è il collo di bottiglia, non la GPU.

   bash

   # if data_s creeps toward updt_s
   lerobot-train ... --num_workers=8

5. 5
   Raccogliere checkpoint da confrontare

   save_freq è impostato di default a 20000, quindi un'esecuzione di 20000 passi lascia un solo checkpoint e nulla con cui confrontarlo. Imposta 2000. Il push all'Hub richiede --policy.repo_id.

   bash

   --save_freq=2000 \
   --policy.repo_id=${HF_USER}/smolvla_pick_place \
   --save_checkpoint_to_hub=true

6. 6
   Riprendere se la macchina si blocca

   Punta --config_path al train_config.json accanto al checkpoint. lerobot si rifiuta di avviare in una output_dir esistente a meno che tu non stia riprendendo, quindi non puoi sovrascrivere un'esecuzione per errore.

   bash

   lerobot-train \
     --config_path=<path to the saved train_config.json> \
     --resume=true

I flag che effettivamente cambiano il risultato

Le impostazioni predefinite che erediti se non modifichi nulla

Una configurazione in lerobot include il proprio preset di ottimizzatore e scheduler, e a meno che tu non imposti use_policy_training_preset=false quei preset prevalgono. Metà delle domande che le persone pongono sull'addestramento di SmolVLA trovano risposta in un'impostazione predefinita di cui non conoscevano l'esistenza.

Le due righe che sorprendono le persone sono freeze_vision_encoder e train_expert_only, entrambe vere. Di default si addestrano circa 100 M parametri, non 450 M, motivo per cui si adatta a 24 GB. L'esecuzione di riferimento di LeRobot su un cluster H100 a quattro GPU imposta entrambe su false; su una scheda da 24 GB questo trasforma un'esecuzione funzionante in .

Quanto tempo impiega l'esecuzione e quanti passi sono sufficienti

LeRobot pubblica riferimenti temporali (wall-clock) per cinque epoche su un dataset di circa 50 episodi, circa 45000 frame a 30 fps. Sono cifre dell'ordine di grandezza, dicono i documenti, ma fanno la differenza tra aspettarsi un'ora e un giorno.

Esecuzione della policy ottimizzata sul braccio robotico

lerobot-rollout \
  --strategy.type=base \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower_arm \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
  --task="Grasp the cube and put it in the box." \
  --policy.path=${HF_USER}/smolvla_pick_place

I 245 ms per passo d'azione sono facili da interpretare erroneamente: la policy emette chunk_size = 50 azioni per passaggio forward ed esegue n_action_steps = 50 di esse, quindi la frequenza con cui si paga quel costo è impostata da questi parametri, non dalla frequenza con cui i servi ricevono un comando. Questo è ciò che offre, e perché un modello da 245 ms può pilotare un braccio a 30 Hz. Ciò che rimane è la alla fine del chunk.

Quella terza riga è ciò che la maggior parte delle descrizioni omette. L'inferenza asincrona è circa il 30 percento più veloce e raddoppia approssimativamente il throughput in una finestra fissa, e il documento definisce i tassi di successo comparabili, cosa che in media sono. Sotto di essa, l'ordinamento è sceso dal 70 al 50 percento mentre il pick and place ha guadagnato 5. lerobot 0.6.1 porta l'altra leva nello stesso binario: --inference.type=rtc commuta il rollout al chunking in tempo reale, che il blocco di utilizzo dello script stesso raccomanda per i VLA lenti, Pi0, Pi0.5 e SmolVLA.

Due percorsi allo stesso checkpoint

pip install 'lerobot[smolvla,training,core_scripts]'
hf auth login

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=${HF_USER}/so100_pick_place \
  --batch_size=8 --steps=20000 \
  --save_freq=2000 --seed=1000 \
  --output_dir=outputs/train/smolvla_pick_place \
  --job_name=smolvla_pick_place \
  --policy.device=cuda --wandb.enable=true

Quando SmolVLA è la scelta sbagliata

Il test per stabilire se SmolVLA fosse la prima esecuzione giusta non è se abbia funzionato, ma se il fallimento ti abbia detto qualcosa. Raggiungi il 60 o 70 percento e un modello più grande è una spesa successiva ragionevole: i dati portano un segnale. Raggiungi il 10 percento e un modello da 3 B molto probabilmente raggiunge anch'esso il 10 percento, cosa che hai appena imparato per tre dollari invece di dodici.

Vale la pena leggere prima di spendere di più: Pi0.5 contro SmolVLA per una maggiore capacità sulla stessa idea, e GR00T N1.7 contro SmolVLA per il percorso NVIDIA, entrambi di livello 80 GB a 4-12 USD per esecuzione. L'altro modo, ACT è la base di riferimento più economica: 80 M parametri, 20 ms per passo d'azione, nessun condizionamento linguistico. Tutti e cinque si trovano su la pagina delle policy; l'arena ha 85 modelli e 332 risultati di benchmark.

La checklist prima di scalare qualsiasi cosa

1. Il lr ha raggiunto il suo limite inferiore di 2.5e-6? Sotto i 30000 passi lerobot ricalibra il decadimento e lo indica all'avvio; sopra, imposta --policy.scheduler_decay_steps manualmente.
2. Più di un checkpoint, ed episodi tenuti da parte con --dataset.eval_split in modo che la perdita di valutazione abbia un significato.
3. La policy si muove affatto? Una perdita in calo con un braccio immobile ha cause specifiche: la perdita diminuisce, la policy non fa nulla.
4. Sopravvive a un cambio di scena? Se no: la policy funziona solo in una configurazione.
5. Hai annotato il seed? lerobot imposta 1000 come predefinito, quindi due esecuzioni non modificate rimangono comparabili.
6. Solo allora: più episodi, più variazione o un modello più grande. In quest'ordine.

Perché questi modelli esistono e cosa fanno con l'input linguistico, , è il contesto; esegue l'assemblaggio attraverso fino alla prima esecuzione di . Per il checkpoint finale, ; se il braccio non appare mai, .