Paano Sanayin ang SmolVLA sa isang 24 GB GPU (lerobot 0.6.1)

Karamihan sa mga taong gustong magkaroon ng modelo ng aksyon sa wika at paningin sa isang tunay na braso ay humihinto sa linya ng hardware. GR00T N1.7 at Pi0.5 ay humigit-kumulang tatlong bilyong parameter bawat isa at nangangailangan ng A100 80 GB o isang H100. Kung ang pag-aari mo ay isang gaming PC na may RTX 4090, iyon na ang katapusan ng daan. SmolVLA ang eksepsyon: 450 M na parameter, sa loob ng LeRobot, na binuo upang i-fine-tune sa isang consumer card at magsilbi mula sa isang CPU.

Ang manu-manong ruta muna: i-install ang lerobot, i-pull ang lerobot/smolvla_base checkpoint, patakbuhin ang tunay na command, basahin ang pagtakbo habang nangyayari ito. Pagkatapos ang ruta ng platform, at kung saan ito hindi nakakatulong.

Ano ang SmolVLA, sa mga numerong maaari mong suriin

Ang SmolVLA ay isang pagtutugma ng daloy na patakaran na ikinabit sa isang maliit na modelo ng wika ng paningin. Ang backbone ay SmolVLM2-500M-Video-Instruct; ang papel ay pinanatili lamang ang unang 16 na layer ng modelo ng wika nito, nililimitahan ang bawat frame ng camera sa 64 na visual token gamit ang pixel shuffle sa halip na pag-tile ng imahe, at pinagsasama ang cross attention sa isang self attention layer bawat ikalawang bloke. Ang gastos sa inference ay isang hadlang sa disenyo, hindi isang huling pag-iisip.

Ang mga benchmark ang dahilan kung bakit pinagkakaabalahan ng mga tao ang isang 450 M na modelo. Sa LIBERO, nag-a-average ito ng 87.3 porsyento laban sa 76.5 para sa OpenVLA sa 7 B at 86.0 para sa isang Pi0 na na-pretrain sa robotics sa 3.3 B; sa Meta-World, 57.3 laban sa 47.9. Sa tunay na SO-100 hardware, ang multi-task training ay nagbibigay ng 75 porsyento sa pick and place, 90 sa stacking, 70 sa sorting, na nag-a-average ng 78.3, kung saan ACT na sinanay bawat gawain ay nag-average ng 48.3. Ang parehong mga hilera ay matatagpuan sa tabi ng bawat nailathalang VLA sa SmolVLA entry sa arena at ang paghahambing ng ACT laban sa SmolVLA.

Bakit ang 24 GB card ang tamang unang pagpapatakbo

Nagbibigay ang LeRobot ng compute sizing guide, ang pinakamakapakinabang na pahina sa repo para dito. Pinagsasama-sama nito ang mga policy ayon sa laki ng backbone at nagbibigay ng isang VRAM envelope bawat grupo, na sinusukat sa batch size 8 gamit ang AdamW, ang default ng lerobot. Ang optimizer state lamang ay nagdaragdag ng 30 hanggang 100 porsyento sa isang simpleng forward at backward pass, kaya hindi ito mga figure na para sa weights lamang.

Sampu hanggang labing-anim na gigabytes sa batch 8 ang argumento: ang isang 24 GB card ay kasya doon kasama ang dataloader. Inilalagay ng AY-Robots ang SmolVLA sa RTX 4090 o anumang 24 GB card, minimum 30 mga episode, LeRobot v3.0 data, 245 ms bawat action step. Kapag inupahan, ito ay 2 hanggang 5 oras sa 0.30 hanggang 0.60 USD bawat oras, humigit-kumulang 1 hanggang 3 USD bawat fine-tuning run, laban sa 4 hanggang 12 USD sa 80 GB tier na kailangan ng GR00T at Pi0.5 (pagpepresyo). Ang isang bigong SmolVLA run ay kape; ang isang bigong GR00T run, tanghalian.

Hakbang 0: ang dataset ang nagpapasya sa pagtakbo, hindi ang mga flag

Walang saysay ang lahat ng nasa ibaba kung masama ang recording. Ang pahina ng LeRobot SmolVLA ay direkta: ang reference dataset ay 50 episodes sa 5 posisyon ng cube, 10 bawat posisyon, at ang parehong gawain sa 25 episodes ay nagpakita ng masamang performance. Ang pag-uulit bawat variation ay nagiging pangkalahatan, ang bilang ng raw episode ay hindi. Hindi pa nakapag-record? Magsimula sa i-record ang iyong unang dataset gamit ang client ng desktop, na nagsusulat ng LeRobot format mula sa isang teleoperation session, o humiram ng isa mula sa direktoryo ng dataset.

• Hindi bababa sa 30 episode sa AY-Robots, mga 50 para sa LeRobot reference recipe.
• Bawat variation na inaasahan mo sa rollout, inulit nang ilang beses.
• Isang task string, na binaybay nang magkapareho sa oras ng pag-record at rollout. Ang modelo ay nakakondisyon sa tekstong iyon.
• Nakapirming camera. Ang isang camera na inilipat sa pagitan ng pag-record at rollout ay ang pinakakaraniwang dahilan kung bakit ang isang malinis na loss curve ay nagbibigay ng walang galaw na braso.
• Isang held-out variation na hindi mo kailanman sinanay, upang mayroon kang matapat na pagsubok.

# 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

Higit pa tungkol dito sa paano mangolekta ng mataas na kalidad na data ng pagsasanay ng VLA. Ang maikling bersyon: 30 hanggang 50 malinis na episode ng isang gawain na may sinadyang variation ay mas mahusay kaysa sa 200 maluwag na episode ng tatlo, sa isang margin na hindi kayang isara ng anumang hyperparameter.

I-install ang 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

Ang base lerobot install ay manipis at nagtatago ng mabibigat na dependencies sa likod ng mga extras: smolvla nagdaragdag ng transformers, num2words at accelerate, training ang dataset stack at wandb, core_scripts ang hardware at visualisation deps. Sa Linux, ang install path din ang nagdedesisyon sa iyong CUDA wheel: ang default ng PyPI ay isang cu130 wheel na may driver floor na 580.65, kaya sa mas lumang driver, i-install muna ang torch mula sa cu128 index, pagkatapos ay ang lerobot.

Ang pagpapatakbo ng pagsasanay, utos sa bawat utos

1. 1
   Mag-authenticate sa Hub

   Ang base checkpoint ay nagmula sa Hub, at malamang na ganoon din ang iyong dataset.

   bash

   hf auth login

2. 2
   Basahin ang mga opsyon nang isang beses

   Bawat field ng pipeline at policy config ay isang flag. Basahin ito nang mabilis bago suriin ang source.

   bash

   lerobot-train --help

3. 3
   Simulan ang fine-tune

   Ang halimbawa sa docs ay nagpapatakbo ng batch 64 sa isang A100; ang sariling A100 40 GB anchor ng compute guide ay batch 16, at ang 8 ay ang katumbas ng 24 GB. Walang scheduler flag dito nang sadya, tingnan sa ibaba.

   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
   Basahin ang log line, hindi lang ang loss

   Sa bawat --log_freq na hakbang, inililimbag ng lerobot ang loss, grdn, lr, updt_s, data_s, smp/s at, sa CUDA, mem_gb. Sinasabi ng mem_gb kung kasya ang batch, ng lr kung bumababa ang schedule, at ang data_s na lumalapit sa updt_s ay nangangahulugang ang dataloader ang bottleneck, hindi ang GPU.

   bash

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

5. 5
   Kolektahin ang mga checkpoint na maaari mong ikumpara

   Ang save_freq ay default sa 20000, kaya ang isang 20000-step na pagpapatakbo ay nag-iiwan ng isang checkpoint at walang maihahambing dito. Itakda sa 2000. Ang pagtulak sa Hub ay nangangailangan ng --policy.repo_id.

   bash

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

6. 6
   Ipagpatuloy kung mamatay ang makina

   Ituro ang --config_path sa train_config.json sa tabi ng checkpoint. Tumanggi ang lerobot na magsimula sa isang umiiral na output_dir maliban kung ipagpapatuloy mo, kaya hindi mo maaaring aksidenteng i-overwrite ang isang run.

   bash

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

Ang mga flag na talagang nagbabago sa resulta

Ang mga default na iyong minana kung wala kang gagalawin

Isang patakaran config sa lerobot ay nagdadala ng sarili nitong optimizer at scheduler preset, at maliban kung itatakda mo ang use_policy_training_preset=false ang mga preset na iyon ang mananaig. Kalahati ng mga tanong na itinatanong ng mga tao tungkol sa pagsasanay ng SmolVLA ay sinasagot ng isang default na hindi nila alam na umiiral.

Ang dalawang linya na nakakagulat sa mga tao ay freeze_vision_encoder at train_expert_only, parehong totoo. Sa simula, nagsasanay ka ng humigit-kumulang 100 M na parameter, hindi 450 M, kaya ito kasya sa 24 GB. Ang sariling reference run ng LeRobot sa isang four-GPU H100 cluster ay ginagawang false ang pareho; sa isang 24 GB card, ginagawa nitong .

Gaano katagal ang takbo, at ilang hakbang ang sapat

Ang LeRobot ay naglalabas ng wall-clock anchors para sa limang epoch sa isang humigit-kumulang 50 episode dataset, mga 45000 frame sa 30 fps. Mga pigura ng order of magnitude, ayon sa mga docs, ngunit ito ang pagkakaiba sa pagitan ng pag-asa ng isang oras at isang araw.

Pagpapatakbo ng na-fine-tune na patakaran pabalik sa braso

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

Ang 245 ms bawat hakbang ng aksyon ay madaling maliwanagan: ang patakaran ay naglalabas ng chunk_size = 50 aksyon bawat forward pass at nagpapatupad ng n_action_steps = 50 sa mga ito, kaya kung gaano kadalas mo babayaran ang gastos na iyon ay itinakda ng mga kontrol na iyon, hindi ng kung gaano kadalas nakakatanggap ng utos ang mga servo. Iyan ang binibili ng pag-chunk ng aksyon, at kung bakit ang isang 245 ms na modelo ay kayang magpatakbo ng 30 Hz na braso. Ang natitira ay latency ng inference sa dulo ng chunk.

Ang ikatlong hilera na iyon ang kadalasang nilalaktawan ng karamihan sa mga sulatin. Ang async inference ay humigit-kumulang 30 porsiyentong mas mabilis at halos doble ang throughput sa isang nakapirming window, at tinatawag ng papel na maihahambing ang mga rate ng tagumpay, na sa average ay totoo. Sa ilalim nito, bumaba ang pag-uuri mula 70 hanggang 50 porsiyento habang ang pick and place ay tumaas ng 5. Ang lerobot 0.6.1 ay nagdadala ng isa pang lever sa parehong binary: --inference.type=rtc ay nagpapalit ng rollout sa real time chunking, na inirerekomenda ng sariling usage block ng script para sa mabagal na mga VLA, Pi0, Pi0.5 at SmolVLA.

Dalawang ruta patungo sa parehong 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

Kapag mali ang pagpili ng SmolVLA

Ang pagsubok kung ang SmolVLA ang tamang unang pagtakbo ay hindi kung ito ay gumana, kundi kung may sinabi sa iyo ang pagkabigo. Abutin ang 60 o 70 porsiyento at ang isang mas malaking modelo ay isang makatwirang susunod na gastusin: ang data ay nagdadala ng signal. Abutin ang 10 porsiyento at ang isang 3 B na modelo ay malamang na umabot din sa 10 porsiyento, na natutunan mo lang sa halagang tatlong dolyar sa halip na labindalawa.

Sulit basahin bago gumastos pa: Pi0.5 against SmolVLA para sa mas malaking kapasidad sa parehong ideya, at GR00T N1.7 against SmolVLA para sa ruta ng NVIDIA, parehong 80 GB tier sa 4 to 12 USD bawat takbo. Sa kabilang banda, ACT ang mas murang baseline: 80 M parameters, 20 ms bawat action step, walang language conditioning. Lahat ng lima ay nasa ang pahina ng mga policy; ang arena ay may 85 modelo at 332 benchmark result.

Ang checklist bago ka mag-scale ng kahit ano

1. Naabot ba ng lr ang 2.5e-6 na floor nito? Sa ibaba ng 30000 steps, binabago ng lerobot ang decay at sinasabi ito sa startup; sa itaas nito, itakda ang --policy.scheduler_decay_steps nang ikaw mismo.
2. Higit sa isang checkpoint, at mga episode na inalis gamit ang --dataset.eval_split upang magkaroon ng kahulugan ang eval loss.
3. Gumagalaw ba ang policy? Ang bumababang loss na may hindi gumagalaw na braso ay may partikular na sanhi: bumababa ang loss, walang ginagawa ang policy.
4. Nakakaligtas ba ito sa pagbabago ng eksena? Kung hindi: gumagana lang ang policy sa isang setup.
5. Isinulat mo ba ang seed? Ang lerobot ay nagde-default sa 1000, kaya ang dalawang hindi nagalaw na run ay nananatiling maihahambing.
6. Pagkatapos lamang: mas maraming episode, mas maraming variation, o mas malaking modelo. Sa ganoong pagkakasunod-sunod.

Para sa kung bakit umiiral ang mga modelong ito at kung ano ang ginagawa nila sa input ng wika, ang background; ay nagpapatakbo ng assembly sa pamamagitan ng hanggang sa unang run. Para sa natapos na checkpoint, ; kung hindi lumabas ang braso, .