Hur man tränar SmolVLA på en 24 GB GPU (lerobot 0.6.1)

De flesta som vill ha en visionsspråk-aktionsmodell på en riktig arm stannar vid hårdvarugränsen. GR00T N1.7 och Pi0.5 är runt tre miljarder parametrar vardera och kräver en A100 80 GB eller en H100. Om du äger en speldator med ett RTX 4090, är det slutet på vägen. SmolVLA är undantaget: 450 M parametrar, inuti LeRobot, byggd för att finjusteras på ett konsumentkort och köras från en CPU.

Den manuella vägen först: installera lerobot, hämta lerobot/smolvla_base checkpointen, kör det riktiga kommandot, läs körningen medan den pågår. Sedan plattformsvägen, och var den inte hjälper.

Vad SmolVLA är, i siffror du kan kontrollera

SmolVLA är en flödesmatchning policy kopplad till en liten vision-språkmodell. Ryggraden är SmolVLM2-500M-Video-Instruct; artikeln behåller endast de första 16 lagren av dess språkmodell, begränsar varje kamerabild till 64 visuella tokens med en pixel shuffle istället för bildplattläggning, och varvar korsuppmärksamhet med ett självuppmärksamhetslager varannat block. Inferenskostnaden var en designbegränsning, inte en eftertanke.

Prestandatesterna är anledningen till att folk bryr sig om en 450 M-modell. På LIBERO uppnår den i genomsnitt 87,3 procent mot 76,5 för OpenVLA vid 7 B och 86,0 för en robotik-förtränad Pi0 vid 3,3 B; på Meta-World, 57,3 mot 47,9. På verklig SO-100-hårdvara ger multi-task-träning 75 procent på plocka och placera, 90 på stapling, 70 på sortering, med ett genomsnitt på 78,3, där ACT tränad per uppgift i genomsnitt uppnådde 48,3. Samma rader finns bredvid varje publicerad VLA i SmolVLA arena-post och jämförelsen mellan ACT och SmolVLA.

Varför ett 24 GB-kort är det rätta för första körningen

LeRobot levererar en beräkningsstorleksguide, den mest användbara sidan i repot för detta. Den grupperar policyer efter backbone-storlek och ger en VRAM-budget per grupp, mätt vid batchstorlek 8 med AdamW, lerobots standard. Optimeringsstatusen ensam lägger till 30 till 100 procent utöver en ren framåt- och bakåtpass, så dessa är inte enbart viktsiffror.

Tio till sexton gigabyte vid batch 8 är argumentet: ett 24 GB-kort rymmer det plus dataladdaren. AY-Robots placerar SmolVLA på RTX 4090 eller vilket som helst 24 GB-kort, minst 30 episoder, LeRobot v3.0 data, 245 ms per åtgärdssteg. Hyrt, det är 2 till 5 timmar för 0.30 till 0.60 USD i timmen, cirka 1 till 3 USD per finjusterings körning, jämfört med 4 till 12 USD på 80 GB-nivån som GR00T och Pi0.5 behöver (prissättning). En misslyckad SmolVLA-körning är en kaffe; en misslyckad GR00T-körning, lunch.

Steg 0: datasetet avgör körningen, inte flaggorna

Inget nedan spelar roll om inspelningen är dålig. LeRobot SmolVLA-sidan är rakt på sak: referensdatasetet var 50 episoder över 5 kubpositioner, 10 per position, och samma uppgift med 25 episoder presterade dåligt. Repetition per variation generaliserar, rått episodantal gör det inte. Har du aldrig spelat in en? Börja med spela in ditt första dataset med skrivbordsklienten, som skriver LeRobot-format från en teleoperation-session, eller låna en från datasetkatalogen.

• Minst 30 avsnitt på AY-Robots, cirka 50 för LeRobot referensreceptet.
• Varje variation du förväntar dig vid utrullning, upprepad flera gånger.
• En uppgiftssträng, stavat identiskt vid inspelnings- och utrullningstillfället. Modellen är villkorad av den texten.
• Fasta kameror. En kamera som flyttats mellan inspelning och utrullning är den vanligaste anledningen till att en ren förlustkurva ger en orörlig arm.
• En undanhållen variation du aldrig tränat på, så att du har något ärligt att testa mot.

# 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

Mer om detta i hur man samlar in högkvalitativ VLA-träningsdata. Den korta versionen: 30 till 50 rena avsnitt av en uppgift med avsiktlig variation slår 200 slarviga avsnitt av tre, med en marginal som ingen hyperparameter kan överbrygga.

Installera 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

Bas-lerobot installationen är tunn och döljer tunga beroenden bakom tillägg: smolvla lägger till transformers, num2words och accelerate, training dataset-stacken och wandb, och core_scripts hårdvaru- och visualiseringsberoendena. På Linux bestämmer installationssökvägen även din CUDA-wheel: PyPI-standard är en cu130-wheel med ett drivrutinsgolv på 580.65, så med en äldre drivrutin installerar du torch från cu128-indexet först, sedan lerobot.

Träningskörningen, kommando för kommando

1. 1
   Autentisera mot Hubben

   Bas-checkpointen kommer från Hubben, och ditt dataset gör det förmodligen också.

   bash

   hf auth login

2. 2
   Läs alternativen en gång

   Varje fält i pipeline- och policykonfigurationen är en flagga. Skumma igenom den innan du gräver i källkoden.

   bash

   lerobot-train --help

3. 3
   Starta finjusteringen

   Exemplet i dokumentationen kör batch 64 på en enda A100; beräkningsguidens egen A100 40 GB-referens är batch 16, och 8 är motsvarigheten för 24 GB. Ingen scheduler-flagga här med avsikt, se nedan.

   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
   Läs loggraden, inte bara förlusten

   Varje --log_freq steg skriver lerobot ut loss, grdn, lr, updt_s, data_s, smp/s och, på CUDA, mem_gb. mem_gb anger om batchen får plats, lr om schemat avtar, och data_s som närmar sig updt_s betyder att dataloadern är flaskhalsen, inte GPU:n.

   bash

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

5. 5
   Samla checkpoints du kan jämföra

   save_freq är som standard 20000, så en körning på 20000 steg lämnar en checkpoint och inget att jämföra den med. Sätt 2000. Att pusha till Hubben kräver --policy.repo_id.

   bash

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

6. 6
   Återuppta om maskinen dör

   Peka --config_path mot train_config.json bredvid checkpointen. lerobot vägrar att starta i en befintlig output_dir om du inte återupptar, så du kan inte skriva över en körning av misstag.

   bash

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

Flaggorna som faktiskt ändrar resultatet

Standardinställningarna du ärver om du inte rör något

En policy konfiguration i lerobot har sin egen optimerare och schemaläggare förinställd, och om du inte ställer in use_policy_training_preset=false vinner dessa förinställningar. Hälften av frågorna folk ställer om SmolVLA-träning besvaras av en standardinställning de inte visste fanns.

De två rader som överraskar folk är freeze_vision_encoder och train_expert_only, båda sanna. Direkt ur lådan tränar du ungefär 100 M parametrar, inte 450 M, vilket är anledningen till att det passar på 24 GB. LeRobots egen referenskörning på ett H100-kluster med fyra GPU:er ändrar båda till falskt; på ett 24 GB-kort förvandlar det en fungerande körning till .

Hur lång tid körningen tar, och hur många steg som är tillräckligt

LeRobot publicerar referenspunkter för realtidsklockan för fem epoker över en dataset med ungefär 50 avsnitt, cirka 45000 bildrutor vid 30 fps. Storleksordningssiffror, säger dokumentationen, men de är skillnaden mellan att förvänta sig en timme och en dag.

Köra den finjusterade policyn tillbaka på armen

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

De 245 ms per åtgärdssteg är lätta att misstolka: policyn avger chunk_size = 50 åtgärder per framåtkörning och exekverar n_action_steps = 50 av dem, så hur ofta du betalar den kostnaden styrs av dessa parametrar, inte av hur ofta servona får ett kommando. Det är vad åtgärdschunkning köper, och varför en 245 ms modell kan driva en 30 Hz arm. Vad som återstår är inferenslatens i slutet av chunken.

Den tredje raden är vad de flesta rapporter utelämnar. Asynkron inferens är cirka 30 procent snabbare och fördubblar ungefär genomströmningen i ett fast tidsfönster, och artikeln kallar framgångsfrekvenserna jämförbara, vilket de i genomsnitt är. Under ytan sjönk sorteringen från 70 till 50 procent medan plocka och placera ökade med 5. lerobot 0.6.1 bär den andra spaken i samma binärfil: --inference.type=rtc växlar utrullningen till realtidschunkning, vilket skriptets eget användningsblock rekommenderar för de långsamma VLA:erna, Pi0, Pi0.5 och SmolVLA.

Två vägar till samma 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

När SmolVLA är fel val

Testet för om SmolVLA var den rätta första körningen är inte om det fungerade, utan om felet berättade något. Nå 60 eller 70 procent och en större modell är en rimlig nästa investering: datan bär signal. Nå 10 procent och en 3 B-modell når troligen också 10 procent, vilket du just lärde dig för tre dollar istället för tolv.

Värt att läsa innan du spenderar mer: Pi0.5 mot SmolVLA för mer kapacitet på samma idé, och GR00T N1.7 mot SmolVLA för NVIDIA-vägen, båda 80 GB-nivån till 4 till 12 USD per körning. Den andra vägen, ACT är den billigare baslinjen: 80 M parametrar, 20 ms per åtgärdssteg, ingen språkkonditionering. Alla fem finns på policysidan; arenan har 85 modeller och 332 benchmarkresultat.

Checklistan innan du skalar något

1. Nådde lr sin 2.5e-6 gräns? Under 30000 steg skalar lerobot om avklingningen och meddelar detta vid start; över det, ställ in --policy.scheduler_decay_steps själv.
2. Mer än en checkpoint, och episoder undanhållna med --dataset.eval_split så att eval-förlusten betyder något.
3. Rör sig policyn överhuvudtaget? En fallande förlust med en orörlig arm har specifika orsaker: förlusten faller, policyn gör ingenting.
4. Överlever den ett miljöbyte? Om inte: policyn fungerar bara i en konfiguration.
5. Skrev du ner seedet? lerobot använder 1000 som standard, så två orörda körningar förblir jämförbara.
6. Först då: fler episoder, mer variation, eller en större modell. I den ordningen.

För varför dessa modeller existerar och vad de gör med språkinmatningen, är bakgrunden; går igenom montering från till den första . För den färdiga checkpointen, ; om armen aldrig dyker upp, .