Hoe om SmolVLA op 'n 24 GB GPU op te lei (lerobot 0.6.1)

Die meeste mense wat 'n visie-taal-aksie-model op 'n regte arm wil hê, stop by die hardewarelyn. GR00T N1.7 en Pi0.5 is elk ongeveer drie miljard parameters en benodig 'n A100 80 GB of 'n H100. As wat jy besit 'n speletjie-rekenaar met 'n RTX 4090 is, is dit die einde van die pad. SmolVLA is die uitsondering: 450 M parameters, binne LeRobot, gebou om op een verbruikerskaart te verfyn en vanaf 'n SVE te bedien.

Die handmatige roete eers: installeer lerobot, trek die lerobot/smolvla_base kontrolepunt, voer die regte opdrag uit, lees die loop terwyl dit gebeur. Dan die platformroete, en waar dit nie help nie.

Wat SmolVLA is, in syfers wat jy kan nagaan

SmolVLA is 'n vloeipas beleid wat aan 'n klein visie-taalmodel vasgebout is. Die ruggraat is SmolVLM2-500M-Video-Instruct; die referaat behou slegs die eerste 16 lae van sy taalmodel, beperk elke kamera-raam tot 64 visuele tekens met 'n pixel-skuifel in plaas van beeldteëls, en wissel kruis-aandag af met 'n selfaandaglaag elke tweede blok. Afleidingskoste was 'n ontwerpsbeperking, nie 'n nagedagte nie.

Die maatstawwe is hoekom mense die moeite doen met 'n 450 M model. Op LIBERO behaal dit gemiddeld 87.3 persent teenoor 76.5 vir OpenVLA teen 7 B en 86.0 vir 'n robotika-vooropgeleide Pi0 teen 3.3 B; op Meta-World, 57.3 teenoor 47.9. Op regte SO-100 hardeware, lewer multi-taak opleiding 75 persent op optel en plaas, 90 op stapel, 70 op sortering, met 'n gemiddeld van 78.3, waar ACT per taak opgelei gemiddeld 48.3 behaal het. Dieselfde rye staan langs elke gepubliseerde VLA in die SmolVLA arena-inskrywing en die ACT teen SmolVLA vergelyking.

Waarom 'n 24 GB kaart die regte eerste lopie is

LeRobot verskaf 'n rekenaar-groottegids, die nuttigste bladsy in die repo hiervoor. Dit groepeer beleide volgens ruggraatgrootte en gee een VRAM-omhulsel per groep, gemeet teen bondelgrootte 8 met AdamW, die lerobot-verstek. Optimaliseerderstatus alleen voeg 30 tot 100 persent by oor 'n kaal vorentoe- en agtertoe-pas, so dit is nie slegs-gewigte-syfers nie.

Tien tot sestien gigagrepe teen bondel 8 is die argument: 'n 24 GB kaart pas dit plus die datalaaiër. AY-Robots plaas SmolVLA op die RTX 4090 of enige 24 GB kaart, minimum 30 episodes, LeRobot v3.0 data, 245 ms per aksiestap. Gehuur, dit is 2 tot 5 uur teen 0.30 tot 0.60 USD per uur, ongeveer 1 tot 3 USD vir 'n fyninstelling lopie, teenoor 4 tot 12 USD op die 80 GB vlak wat GR00T en Pi0.5 benodig (pryse). 'n Mislukte SmolVLA-lopie is 'n koffie; 'n mislukte GR00T-lopie, middagete.

Stap 0: die datastel besluit die loop, nie die vlae nie

Niks hieronder maak saak as die opname sleg is nie. Die LeRobot SmolVLA bladsy is stomp: die verwysingsdatastel was 50 episodes oor 5 kubusposisies, 10 per posisie, en dieselfde taak by 25 episodes het swak presteer. Herhaling per variasie veralgemeen, rou episode telling doen nie. Nog nooit een opgeneem nie? Begin by neem jou eerste datastel op met die rekenaarkliënt, wat LeRobot-formaat skryf uit 'n tele-operasie sessie, of leen een uit die datastelgids.

• Minstens 30 episodes op AY-Robots, ongeveer 50 vir die LeRobot verwysingsresep.
• Elke variasie wat jy by ontplooiing verwag, verskeie kere herhaal.
• Een taakstring, identies gespel tydens opname en ontplooiing. Die model is gekondisioneer op daardie teks.
• Vaste kameras. 'n Kamera wat tussen opname en ontplooiing verskuif is die mees algemene rede waarom 'n skoon verlieskurwe 'n beweginglose arm gee.
• 'n Uitgehoue variasie waarop jy nooit opgelei het nie, sodat jy iets eerlik het om teen te toets.

# 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

Meer hieroor in hoe om hoë-gehalte VLA-opleidingsdata te versamel. Die kort weergawe: 30 tot 50 skoon episodes van een taak met doelbewuste variasie klop 200 slordige episodes van drie, met 'n marge wat geen hiperparameter kan oorbrug nie.

Installeer 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

Die basis lerobot installasie is skraal en sluit swaar afhanklikhede agter ekstras in: smolvla voeg transformers, num2words en accelerate by, training die datastelstapel en wandb, core_scripts die hardeware- en visualisering-afhanklikhede. Op Linux bepaal die installasiepad ook jou CUDA-wiel: die PyPI-verstek is 'n cu130-wiel met 'n drywervloer van 580.65, so op 'n ouer drywer installeer eers torch vanaf die cu128-indeks, dan lerobot.

Die opleidingslopie, opdrag vir opdrag

1. 1
   Verifieer teen die Hub

   Die basiskontrolepunt kom van die Hub, en jou datastel waarskynlik ook.

   bash

   hf auth login

2. 2
   Lees die opsies een keer

   Elke veld van die pyplyn- en beleidskonfigurasie is 'n vlag. Skim dit voordat jy in die bron delf.

   bash

   lerobot-train --help

3. 3
   Begin die fyninstelling

   Die dokumentasievoorbeeld loop bondel 64 op 'n enkele A100; die rekenaargids se eie A100 40 GB anker is bondel 16, en 8 is die 24 GB ekwivalent. Geen skeduleerder-vlag hier met opset nie, sien hieronder.

   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
   Lees die logreël, nie net die verlies nie

   Elke --log_freq stappe druk lerobot verlies, grdn, lr, updt_s, data_s, smp/s en, op CUDA, mem_gb. mem_gb sê of die bondel pas, lr of die skedule verval, en data_s wat updt_s nader, beteken die datalaai is die knelpunt, nie die GPU nie.

   bash

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

5. 5
   Versamel kontrolepunte wat jy kan vergelyk

   save_freq verstek na 20000, so 'n 20000 stap-lopie laat een kontrolepunt en niks om dit mee te vergelyk nie. Stel 2000. Om na die Hub te stoot benodig --policy.repo_id.

   bash

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

6. 6
   Hervat as die masjien sterf

   Wys --config_path na die train_config.json langs die kontrolepunt. lerobot weier om in 'n bestaande output_dir te begin tensy jy hervat, so jy kan nie 'n lopie per ongeluk oorskryf nie.

   bash

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

Die vlae wat werklik die uitkoms verander

Die verstekwaardes wat jy erf as jy niks aanraak nie

'n beleid konfigurasie in lerobot dra sy eie optimiseerder en skeduleerder voorafinstelling, en tensy jy use_policy_training_preset=false stel, wen daardie voorafinstellings. Die helfte van die vrae wat mense oor SmolVLA-opleiding vra, word beantwoord deur 'n verstekwaarde waarvan hulle nie geweet het bestaan nie.

Die twee reëls wat mense verras is freeze_vision_encoder en train_expert_only, albei waar. Uit die boks oefen jy ongeveer 100 M parameters, nie 450 M nie, en daarom pas dit op 24 GB. LeRobot se eie verwysingslopie op 'n vier-GPU H100-groep stel albei op onwaar; op een 24 GB-kaart verander dit 'n werkende lopie in .

Hoe lank die lopie duur, en hoeveel stappe genoeg is

LeRobot publiseer werklike tydankers vir vyf epogte oor 'n ongeveer 50 episode-datastel, ongeveer 45000 rame teen 30 fps. Orde van grootte syfers, sê die dokumente, maar dit is die verskil tussen om 'n uur en 'n dag te verwag.

Die uitvoering van die fyn-ingestelde beleid terug op die arm

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

Die 245 ms per aksiestap is maklik om verkeerd te lees: die beleid gee chunk_size = 50 aksies per vorentoe-pas uit en voer n_action_steps = 50 daarvan uit, so hoe gereeld jy daardie koste betaal, word deur daardie instellings bepaal, nie deur hoe gereeld die servos 'n opdrag kry nie. Dit is wat aksie-segmentering koop, en hoekom 'n 245 ms model 'n 30 Hz arm kan aandryf. Wat oorbly is inferensie-latensie aan die einde van die segment.

Daardie derde ry is wat die meeste verslae oorslaan. Asinchroniese inferensie is ongeveer 30 persent vinniger en verdubbel rofweg die deurset in 'n vaste tydvenster, en die referaat noem die sukseskoerse vergelykbaar, wat hulle gemiddeld is. Daaronder het sortering van 70 tot 50 persent gedaal terwyl optel en plaas 5 bygekry het. lerobot 0.6.1 dra die ander hefboom in dieselfde binêre lêer: --inference.type=rtc skakel die uitrol oor na intydse segmentering, wat die skrip se eie gebruiksblok aanbeveel vir die stadige VLA's, Pi0, Pi0.5 en SmolVLA.

Twee roetes na dieselfde kontrolepunt

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

Wanneer SmolVLA die verkeerde keuse is

Die toets of SmolVLA die regte eerste lopie was, is nie of dit gewerk het nie, maar of die mislukking jou iets geleer het. Bereik 60 of 70 persent en 'n groter model is 'n redelike volgende uitgawe: die data dra 'n sein. Bereik 10 persent en 'n 3 B model sal heel waarskynlik ook 10 persent bereik, wat jy pas vir drie dollar in plaas van twaalf geleer het.

Die moeite werd om te lees voordat jy meer spandeer: Pi0.5 teen SmolVLA vir meer kapasiteit op dieselfde idee, en GR00T N1.7 teen SmolVLA vir die NVIDIA-roete, beide 80 GB-vlak teen 4 tot 12 USD per lopie. Die ander manier, ACT is die goedkoper basislyn: 80 M parameters, 20 ms per aksiestap, geen taalkondisionering nie. Al vyf is op die beleidsbladsy; die arena het 85 modelle en 332 maatstafresultate.

Die kontrolelys voordat jy enigiets skaal

1. Het die lr sy 2.5e-6 vloer bereik? Onder 30000 stappe herskaal lerobot die verval en meld dit by opstart; bo dit, stel --policy.scheduler_decay_steps self in.
2. Meer as een kontrolepunt, en episodes wat uitgehou is met --dataset.eval_split sodat die eval-verlies iets beteken.
3. Beweeg die beleid enigsins? 'n Dalende verlies met 'n roerlose arm het spesifieke oorsake: verlies daal, beleid doen niks.
4. Oorleef dit 'n verandering van toneel? Indien nie: beleid werk net in een opstelling.
5. Het jy die saad neergeskryf? lerobot stel by verstek op 1000, so twee onveranderde lopies bly vergelykbaar.
6. Eers dan: meer episodes, meer variasie, of 'n groter model. In daardie volgorde.

Vir hoekom hierdie modelle bestaan en wat hulle met die taal-invoer doen, is die agtergrond; loop montering deur na die eerste lopie. Vir die voltooide kontrolepunt, ; as die arm nooit verskyn nie, .