Hvordan trene SmolVLA på en 24 GB GPU (lerobot 0.6.1)

De fleste som ønsker en visuell språk- og handlingsmodell på en ekte arm stopper ved maskinvaregrensen. GR00T N1.7 og Pi0.5 er rundt tre milliarder parametere hver og krever en A100 80 GB eller en H100. Hvis det du eier er en gaming-PC med et RTX 4090, er det slutten på veien. SmolVLA er unntaket: 450 M parametere, inne i LeRobot, bygget for å finjusteres på ett forbrukerkort og serveres fra en CPU.

Den manuelle ruten først: installer lerobot, hent lerobot/smolvla_base sjekkpunktet, kjør den virkelige kommandoen, les kjøringen mens den pågår. Deretter plattformruten, og hvor den ikke hjelper.

Hva SmolVLA er, i tall du kan sjekke

SmolVLA er en flytmatching policy festet til en liten visuell språkmodell. Ryggraden er SmolVLM2-500M-Video-Instruct; artikkelen beholder bare de første 16 lagene av språkmodellen, begrenser hver kameraramme til 64 visuelle tokens med en pikselblanding i stedet for bildeflislegging, og fletter kryss-oppmerksomhet med et selv-oppmerksomhetslag annenhver blokk. Inferenskostnad var en designbegrensning, ikke en ettertanke.

Benchmarkene er grunnen til at folk bryr seg med en 450 M modell. På LIBERO oppnår den et gjennomsnitt på 87.3 prosent mot 76.5 for OpenVLA på 7 B og 86.0 for en robotikk-førtrent Pi0 på 3.3 B; på Meta-World, 57.3 mot 47.9. På ekte SO-100 maskinvare gir multi-task trening 75 prosent på plukk og plasser, 90 på stabling, 70 på sortering, med et gjennomsnitt på 78.3, der ACT trent per oppgave gjennomsnittlig 48.3. De samme radene står ved siden av hver publiserte VLA i SmolVLA arenaoppføring og ACT mot SmolVLA sammenligning.

Hvorfor et 24 GB-kort er det rette førstevalget

LeRobot leverer en veiledning for beregningsstørrelse, den mest nyttige siden i repoet for dette. Den grupperer retningslinjer etter ryggrads-størrelse og angir én VRAM-ramme per gruppe, målt med batchstørrelse 8 med AdamW, som er standarden i lerobot. Optimaliseringstilstanden alene legger til 30 til 100 prosent utover en ren fremover- og bakoverpassering, så dette er ikke tall basert kun på vekter.

Ti til seksten gigabyte ved batchstørrelse 8 er argumentet: et 24 GB-kort passer til det pluss datalasteren. AY-Robots plasserer SmolVLA på RTX 4090 eller et hvilket som helst 24 GB-kort, minimum 30 episoder, LeRobot v3.0 data, 245 ms per handlingstrinn. Leid, det er 2 til 5 timer til 0.30 til 0.60 USD per time, omtrent 1 til 3 USD per finjustering kjøring, mot 4 til 12 USD på 80 GB-nivået GR00T og Pi0.5 trenger (priser). En mislykket SmolVLA-kjøring er en kaffe; en mislykket GR00T-kjøring, lunsj.

Trinn 0: datasettet bestemmer kjøringen, ikke flaggene

Ingenting nedenfor betyr noe hvis opptaket er dårlig. LeRobot SmolVLA-siden er direkte: referansedatasettet var 50 episoder fordelt på 5 kube-posisjoner, 10 per posisjon, og den samme oppgaven med 25 episoder presterte dårlig. Repetisjon per variasjon generaliserer, rått episodeantall gjør det ikke. Har du aldri tatt opp en? Start med ta opp ditt første datasett med skrivebordsklienten, som skriver LeRobot-format ut av en teleoperasjon-sesjon, eller lån en fra datasettkatalogen.

• Minst 30 episoder på AY-Robots, omtrent 50 for LeRobot referanseoppskriften.
• Hver variasjon du forventer ved utrulling, gjentatt flere ganger.
• Én oppgavestreng, stavet identisk ved opptak og utrulling. Modellen er betinget av den teksten.
• Faste kameraer. Et kamera flyttet mellom opptak og utrulling er den vanligste årsaken til at en ren tapskurve gir en ubevegelig arm.
• En holdt-ut variasjon du aldri trente på, slik at du har noe ærlig å teste 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 dette i hvordan samle inn høykvalitets VLA-treningsdata for robotmanipulasjon. Den korte versjonen: 30 til 50 rene episoder av én oppgave med bevisst variasjon slår 200 slurvete episoder av tre, med en margin ingen hyperparameter lukker.

Installer 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

Grunnleggende lerobot installasjonen er tynn og gjerder tunge avhengigheter bak tilleggspakker (extras): smolvla legger til transformers, num2words og accelerate, training dataset-stakken og wandb, core_scripts maskinvare- og visualiseringsavhengighetene. På Linux bestemmer installasjonsstien også ditt CUDA-hjul: PyPI-standard er et cu130-hjul med et drivergulv på 580.65, så på en eldre driver installerer du torch fra cu128-indeksen først, deretter lerobot.

Treningskjøringen, kommando for kommando

1. 1
   Autentiser mot Hub-en

   Grunn-sjekkpunktet kommer fra Hub-en, og datasettet ditt gjør sannsynligvis det også.

   bash

   hf auth login

2. 2
   Les alternativene én gang

   Hvert felt i pipeline- og policykonfigurasjonen er et flagg. Skum gjennom det før du graver i kildekoden.

   bash

   lerobot-train --help

3. 3
   Start finjusteringen

   Eksemplet i dokumentasjonen kjører batch 64 på en enkelt A100; beregningsveiledningens egen A100 40 GB-referanse er batch 16, og 8 er 24 GB-ekvivalenten. Ingen scheduler-flagg her med vilje, se nedenfor.

   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
   Les logglinjen, ikke bare tapet

   Hvert --log_freq trinn skriver lerobot ut loss, grdn, lr, updt_s, data_s, smp/s og, på CUDA, mem_gb. mem_gb sier om batchen passer, lr om tidsplanen avtar, og data_s som nærmer seg updt_s betyr at datalasteren er flaskehalsen, ikke GPU-en.

   bash

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

5. 5
   Samle sjekkpunkter du kan sammenligne

   save_freq er som standard 20000, så en kjøring på 20000 trinn etterlater ett sjekkpunkt og ingenting å sammenligne det med. Sett 2000. For å pushe til Hub-en kreves --policy.repo_id.

   bash

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

6. 6
   Gjenoppta hvis maskinen dør

   Pek --config_path til train_config.json ved siden av sjekkpunktet. lerobot nekter å starte i en eksisterende output_dir med mindre du gjenopptar, slik at du ikke kan overskrive en kjøring ved et uhell.

   bash

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

Flaggene som faktisk endrer resultatet

Standardinnstillingene du arver hvis du ikke rører noe

En konfigurasjon i lerobot har sin egen optimalisator og planlegger forhåndsinnstilt, og med mindre du setter use_policy_training_preset=false vinner disse forhåndsinnstillingene. Halvparten av spørsmålene folk stiller om SmolVLA-trening besvares av en standardinnstilling de ikke visste eksisterte.

De to linjene som overrasker folk er freeze_vision_encoder og train_expert_only, begge sanne. Ut av boksen trener du omtrent 100 M parametere, ikke 450 M, noe som er grunnen til at det passer på 24 GB. LeRobots egen referansekjøring på et fire-GPU H100-klyngesystem setter begge til usant; på ett 24 GB-kort gjør det en fungerende kjøring om til .

Hvor lang tid kjøringen tar, og hvor mange trinn som er nok

LeRobot publiserer veggklokke-ankere for five epochs over a roughly 50 episode dataset, about 45000 frames at 30 fps. Størrelsesordens tall, sier dokumentasjonen, men de utgjør forskjellen mellom å forvente en time og en dag.

Kjører den finjusterte policyen tilbake 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 handlingstrinn er lett å misforstå: policyen sender ut chunk_size = 50 handlinger per fremoverpass og utfører n_action_steps = 50 av dem, så hvor ofte du betaler den kostnaden er satt av disse innstillingene, ikke av hvor ofte servoene får en kommando. Det er hva handlingssegmentering kjøper, og hvorfor en 245 ms modell kan drive en 30 Hz arm. Det som gjenstår er inferensforsinkelse på slutten av segmentet.

Den tredje raden er det de fleste rapporter hopper over. Asynkron inferens er omtrent 30 prosent raskere og dobler omtrent gjennomstrømningen i et fast vindu, og artikkelen kaller suksessratene sammenlignbare, noe de i gjennomsnitt er. Under overflaten falt sortering fra 70 til 50 prosent mens plukk og plasser økte med 5. lerobot 0.6.1 bærer den andre spaken i samme binærfil: --inference.type=rtc bytter utrullingen til sanntidssegmentering, noe skriptets egen bruksblokk anbefaler for de trege VLA-ene, Pi0, Pi0.5 og SmolVLA.

To veier til samme sjekkpunkt

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 er feil valg

Testen for om SmolVLA var det rette første forsøket er ikke om det fungerte, men om feilen fortalte deg noe. Oppnår du 60 eller 70 prosent, er en større modell en rimelig neste investering: dataene inneholder signal. Oppnår du 10 prosent, vil en 3 B-modell mest sannsynlig også oppnå 10 prosent, noe du nettopp lærte for tre dollar i stedet for tolv.

Verdt å lese før du bruker mer: Pi0.5 mot SmolVLA for mer kapasitet på samme idé, og GR00T N1.7 mot SmolVLA for NVIDIA-ruten, begge 80 GB-nivå til 4 til 12 USD per kjøring. Den andre veien, ACT er den billigere grunnlinjen: 80 M parametere, 20 ms per handlingstrinn, ingen språkbetinging. Alle fem ligger på policy-siden; arenaen har 85 modeller og 332 benchmark-resultater.

Sjekklisten før du skalerer noe

1. Nådde lr sitt gulv på 2.5e-6? Under 30000 steg skalerer lerobot ned forfallet og sier ifra ved oppstart; over dette, sett --policy.scheduler_decay_steps selv.
2. Mer enn ett sjekkpunkt, og episoder holdt tilbake med --dataset.eval_split slik at evalueringsfeilen betyr noe.
3. Beveger policyen seg i det hele tatt? Et fallende tap med en urørlig arm har spesifikke årsaker: feilen faller, men policyen gjør ingenting.
4. Overlever den et sceneskifte? Hvis ikke: policyen fungerer bare i ett oppsett.
5. Skrev du ned frøet (seed)? lerobot bruker 1000 som standard, slik at to uberørte kjøringer forblir sammenlignbare.
6. Først da: flere episoder, mer variasjon, eller en større modell. I den rekkefølgen.

For hvorfor disse modellene eksisterer og hva de gjør med språkinndata, er bakgrunnen; kjører montering gjennom til den første -kjøringen. For det ferdige sjekkpunktet, ; hvis armen aldri dukker opp, .