Sådan træner du SmolVLA på en 24 GB GPU (lerobot 0.6.1)

De fleste, der ønsker en vision-sprog-handlingsmodel på en rigtig arm, stopper ved hardwaregrænsen. GR00T N1.7 og Pi0.5 er omkring tre milliarder parametre hver og kræver en A100 80 GB eller en H100. Hvis det, du ejer, er en gaming-pc med et RTX 4090, er det enden på vejen. SmolVLA er undtagelsen: 450 M parametre, inden i LeRobot, bygget til at finjustere på ét forbrugerkort og servere fra en CPU.

Den manuelle rute først: installer lerobot, træk lerobot/smolvla_base checkpointet, kør den rigtige kommando, læs kørslen mens den sker. Derefter platformruten, og hvor den ikke hjælper.

Hvad SmolVLA er, i tal du kan tjekke

SmolVLA er en flow matching politik, der er fastgjort til en lille vision-sprogmodel. Rygraden er SmolVLM2-500M-Video-Instruct; artiklen beholder kun de første 16 lag af dens sprogmodel, begrænser hver kameraramme til 64 visuelle tokens med en pixel shuffle i stedet for billedflisebelægning, og fletter krydsopmærksomhed med et selvopmærksomhedslag hver anden blok. Inferenzomkostninger var en designbegrænsning, ikke en eftertanke.

Benchmark-resultaterne er grunden til, at folk beskæftiger sig med en 450 M model. På LIBERO opnår den i gennemsnit 87,3 procent mod 76,5 for OpenVLA på 7 B og 86,0 for en robotik-forudtrænet Pi0 på 3,3 B; på Meta-World, 57,3 mod 47,9. På ægte SO-100 hardware giver multi-task træning 75 procent på grib og placer, 90 på stabling, 70 på sortering, med et gennemsnit på 78,3, hvor ACT trænet pr. opgave i gennemsnit opnåede 48,3. De samme rækker findes ved siden af hver publiceret VLA i SmolVLA arena-indgangen og ACT mod SmolVLA sammenligningen.

Hvorfor et 24 GB kort er det rette til den første kørsel

LeRobot leverer en guide til beregningsstørrelse, den mest nyttige side i repoet til dette. Den grupperer politikker efter backbone-størrelse og angiver én VRAM-ramme pr. gruppe, målt ved batchstørrelse 8 med AdamW, som er lerobot-standard. Optimeringsstatus alene tilføjer 30 til 100 procent ud over en ren forward- og backward-pass, så disse er ikke tal, der udelukkende repræsenterer vægte.

Ti til seksten gigabyte ved batch 8 er argumentet: et 24 GB kort passer til det plus dataloaderen. AY-Robots placerer SmolVLA på RTX 4090 eller ethvert 24 GB kort, minimum 30 episoder, LeRobot v3.0 data, 245 ms pr. handlingstrin. Lejet, det er 2 til 5 timer til 0.30 til 0.60 USD i timen, ca. 1 til 3 USD pr. finjusteringskørsel, mod 4 til 12 USD på 80 GB tier, som GR00T og Pi0.5 kræver (priser). En mislykket SmolVLA-kørsel er en kaffe; en mislykket GR00T-kørsel, frokost.

Trin 0: datasættet bestemmer kørslen, ikke flagene

Intet nedenfor betyder noget, hvis optagelsen er dårlig. LeRobot SmolVLA-siden er direkte: referencedatasættet var 50 episoder fordelt på 5 terningpositioner, 10 pr. position, og den samme opgave udført med 25 episoder klarede sig dårligt. Gentagelse pr. variation generaliserer, råt episodeantal gør ikke. Har du aldrig optaget en? Start ved optag dit første datasæt med desktopklienten, som skriver LeRobot-format ud af en teleoperation-session, eller lån en fra datasætmappen.

• Mindst 30 episoder på AY-Robots, omkring 50 for LeRobot referenceopskriften.
• Hver variation du forventer ved udrulning, gentaget flere gange.
• Én opgavestreng, stavet identisk ved optagelse og udrulning. Modellen er betinget af den tekst.
• Faste kameraer. Et kamera flyttet mellem optagelse og udrulning er den mest almindelige årsag til, at en ren tabskurve giver en ubevægelig arm.
• En tilbageholdt variation, du aldrig har trænet på, så du har noget ærligt at teste imod.

# 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

Mere om dette i hvordan man indsamler træningsdata af høj kvalitet til VLA for robotmanipulation. Den korte version: 30 til 50 rene episoder af én opgave med bevidst variation slår 200 sjuskede episoder af 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

Den grundlæggende lerobot installation er slank og gemmer tunge afhængigheder bag 'extras': smolvla tilføjer transformers, num2words og accelerate, training datasætsstakken og wandb, core_scripts hardware- og visualiseringsafhængighederne. På Linux bestemmer installationsstien også dit CUDA-wheel: PyPI-standard er et cu130-wheel med en drivergrænse på 580.65, så på en ældre driver skal du først installere torch fra cu128-indekset, derefter lerobot.

Træningskørslen, kommando for kommando

1. 1
   Autentificer mod Hub'en

   Basis-checkpointet kommer fra Hub'en, og dit datasæt gør det sandsynligvis også.

   bash

   hf auth login

2. 2
   Læs indstillingerne én gang

   Hvert felt i pipeline- og politikkonfigurationen er et flag. Skim det, før du dykker ned i kildekoden.

   bash

   lerobot-train --help

3. 3
   Start finjusteringen

   Dokumentationseksemplet kører batch 64 på en enkelt A100; compute-guidens egen A100 40 GB anker er batch 16, og 8 er ækvivalenten for 24 GB. Intet scheduler-flag 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
   Læs loglinjen, ikke kun tabet

   Hvert --log_freq trin udskriver lerobot loss, grdn, lr, updt_s, data_s, smp/s og, på CUDA, mem_gb. mem_gb fortæller, om batchen passer, lr om skemaet aftager, og data_s, der nærmer sig updt_s, betyder, at dataloaderen er flaskehalsen, ikke GPU'en.

   bash

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

5. 5
   Indsaml checkpoints, du kan sammenligne

   save_freq er som standard 20000, så en kørsel på 20000 trin efterlader ét checkpoint og intet at sammenligne det med. Sæt til 2000. For at pushe til Hub'en kræves --policy.repo_id.

   bash

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

6. 6
   Genoptag, hvis maskinen dør

   Peg --config_path mod train_config.json ved siden af checkpointet. lerobot nægter at starte i en eksisterende output_dir, medmindre du genoptager, så du kan ikke overskrive en kørsel ved et uheld.

   bash

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

De flags, der faktisk ændrer resultatet

Standardindstillingerne du arver, hvis du ikke rører noget

En politik konfiguration i lerobot indeholder sin egen optimerings- og skemapresets, og medmindre du indstiller use_policy_training_preset=false vinder disse presets. Halvdelen af de spørgsmål, folk stiller om SmolVLA-træning, besvares af en standardindstilling, de ikke vidste eksisterede.

De to linjer, der overrasker folk, er freeze_vision_encoder og train_expert_only, begge sande. Som standard træner du cirka 100 M parametre, ikke 450 M, hvilket er grunden til, at det passer på 24 GB. LeRobots egen referencetest på et fire-GPU H100-cluster sætter begge til falsk; på et enkelt 24 GB kort forvandler det en fungerende kørsel til .

Hvor lang tid kørslen tager, og hvor mange trin der er nok

LeRobot offentliggør "wall-clock" ankerpunkter for fem epoker over et datasæt på cirka 50 episoder, omkring 45000 billeder ved 30 fps. Størrelsesordens tal, siger dokumentationen, men de er forskellen mellem at forvente en time og en dag.

Kør den finjusterede policy tilbage 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 handlingstrin er lette at misforstå: politikken udsender chunk_size = 50 handlinger per forward pass og udfører n_action_steps = 50 af dem, så hvor ofte du betaler den omkostning, bestemmes af disse parametre, ikke af hvor ofte servoerne modtager en kommando. Det er, hvad handlings-chunking køber, og hvorfor en 245 ms model kan drive en 30 Hz arm. Hvad der er tilbage, er inferensforsinkelse ved slutningen af chunken.

Den tredje række er, hvad de fleste rapporter springer over. Asynkron inferens er omkring 30 procent hurtigere og fordobler omtrent gennemløbet i et fast vindue, og artiklen kalder succesraterne sammenlignelige, hvilket de i gennemsnit er. Under overfladen faldt sortering fra 70 til 50 procent, mens pick and place steg med 5. lerobot 0.6.1 indeholder den anden løftestang i samme binære fil: --inference.type=rtc skifter udrulningen til real-time chunking, hvilket scriptets egen brugsblok anbefaler for de langsomme VLA'er, Pi0, Pi0.5 og SmolVLA.

To veje til det samme 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 er det forkerte valg

Testen for, om SmolVLA var det rigtige første forsøg, er ikke, om det virkede, men om fejlen fortalte dig noget. Opnå 60 eller 70 procent, og en større model er en rimelig næste investering: dataene indeholder et signal. Opnå 10 procent, og en 3 B-model vil sandsynligvis også opnå 10 procent, hvilket du lige har lært for tre dollars i stedet for tolv.

Værd at læse, før du bruger mere: Pi0.5 against SmolVLA for mere kapacitet på samme idé, og GR00T N1.7 against SmolVLA for NVIDIA-ruten, begge 80 GB tier til 4 til 12 USD pr. kørsel. Den anden vej, ACT er den billigere baseline: 80 M parametre, 20 ms pr. handlingstrin, ingen sprogkonditionering. Alle fem findes på politikksiden; arenaen har 85 modeller og 332 benchmarkresultater.

Tjeklisten før du skalerer noget

1. Nåede lr sit 2.5e-6 gulv? Under 30000 trin omjusterer lerobot henfaldet og meddeler dette ved opstart; derover skal du selv indstille --policy.scheduler_decay_steps.
2. Mere end ét checkpoint og episoder holdt tilbage med --dataset.eval_split, så evalueringsfejlen betyder noget.
3. Bevæger politikken sig overhovedet? Et faldende tab med en ubevægelig arm har specifikke årsager: tab falder, politikken gør intet.
4. Overlever den et sceneskift? Hvis ikke: politikken virker kun i én opsætning.
5. Skrev du seed'et ned? lerobot bruger som standard 1000, så to uberørte kørsler forbliver sammenlignelige.
6. Først derefter: flere episoder, mere variation eller en større model. I den rækkefølge.

For at forstå hvorfor disse modeller eksisterer, og hvad de gør med sproginputtet, , er baggrunden; gennemgår samling via til den første kørsel. For det færdige checkpoint, ; hvis armen aldrig dukker op, .