24 GB GPUలో SmolVLAని ఎలా శిక్షణ ఇవ్వాలి (lerobot 0.6.1)

చాలా మందికి విజన్ లాంగ్వేజ్ యాక్షన్ మోడల్ నిజమైన ఆర్మ్‌పై కావాలంటే హార్డ్‌వేర్ వద్ద ఆగిపోతారు. GR00T N1.7 మరియు Pi0.5 ఒక్కొక్కటి సుమారు మూడు బిలియన్ పారామీటర్లు కలిగి ఉంటాయి మరియు A100 80 GB లేదా H100 కావాలి. మీ వద్ద RTX 4090తో కూడిన గేమింగ్ PC ఉంటే, అది అక్కడితో ముగిసిపోతుంది. SmolVLA ఒక మినహాయింపు: 450 M పారామీటర్లు, లెరోబోట్ లోపల, ఒక కన్స్యూమర్ కార్డ్‌లో ఫైన్-ట్యూన్ చేయడానికి మరియు CPU నుండి సేవ చేయడానికి నిర్మించబడింది.

ముందుగా మాన్యువల్ మార్గం: లెరోబోట్ ఇన్‌స్టాల్ చేయండి, lerobot/smolvla_base చెక్‌పాయింట్‌ను లాగండి, నిజమైన కమాండ్‌ను అమలు చేయండి, అది జరుగుతున్నప్పుడు రన్‌ను చదవండి. ఆపై ప్లాట్‌ఫారమ్ మార్గం, మరియు అది ఎక్కడ సహాయపడదు.

స్మోల్‌వీఎల్‌ఏ అంటే ఏమిటి, మీరు తనిఖీ చేయగల సంఖ్యలలో

SmolVLA అనేది ఒక ఫ్లో మ్యాచింగ్ పాలసీని చిన్న విజన్ లాంగ్వేజ్ మోడల్‌కు అనుసంధానించారు. దీని బ్యాక్‌బోన్ SmolVLM2-500M-Video-Instruct; ఈ పేపర్ దాని లాంగ్వేజ్ మోడల్ యొక్క మొదటి 16 లేయర్‌లను మాత్రమే ఉపయోగిస్తుంది, ప్రతి కెమెరా ఫ్రేమ్‌ను ఇమేజ్ టైలింగ్‌కు బదులుగా పిక్సెల్ షఫిల్‌తో 64 విజువల్ టోకెన్‌లకు పరిమితం చేస్తుంది మరియు ప్రతి రెండవ బ్లాక్‌లో క్రాస్ అటెన్షన్‌ను సెల్ఫ్ అటెన్షన్ లేయర్‌తో మిళితం చేస్తుంది. ఇన్‌ఫరెన్స్ ఖర్చు అనేది డిజైన్ పరిమితి, ఇది తరువాత ఆలోచించినది కాదు.

450 M మోడల్‌తో ప్రజలు ఎందుకు శ్రద్ధ వహిస్తారనేది బెంచ్‌మార్క్‌లు వివరిస్తాయి. LIBEROలో, ఇది 7 B వద్ద OpenVLA కోసం 76.5 మరియు 3.3 B వద్ద రోబోటిక్స్-ప్రీట్రైన్డ్ Pi0 కోసం 86.0తో పోలిస్తే సగటున 87.3 శాతం సాధించింది; Meta-Worldలో, 47.9తో పోలిస్తే 57.3. నిజమైన SO-100 హార్డ్‌వేర్‌లో, మల్టీ-టాస్క్ ట్రైనింగ్ పిక్ అండ్ ప్లేస్‌లో 75 శాతం, స్టాకింగ్‌లో 90, సార్టింగ్‌లో 70, సగటున 78.3 శాతం ఇస్తుంది, ఇక్కడ ACT ప్రతి టాస్క్‌కు శిక్షణ పొందినది సగటున 48.3. అదే వరుసలు ప్రతి ప్రచురించబడిన VLA పక్కన ఉన్నాయి SmolVLA అరేనా ఎంట్రీ మరియు ACT వర్సెస్ SmolVLA పోలిక.

24 GB కార్డ్ మొదటి రన్‌కు సరైనది ఎందుకు

LeRobot ఒక కంప్యూట్ సైజింగ్ గైడ్‌ను అందిస్తుంది, ఇది ఈ రెపోలో అత్యంత ఉపయోగకరమైన పేజీ. ఇది పాలసీలను బ్యాక్‌బోన్ పరిమాణం ప్రకారం సమూహపరుస్తుంది మరియు ప్రతి సమూహానికి ఒక VRAM ఎన్వలప్‌ను అందిస్తుంది, ఇది AdamWతో బ్యాచ్ సైజ్ 8 వద్ద కొలవబడుతుంది, ఇది lerobot డిఫాల్ట్. ఆప్టిమైజర్ స్టేట్ మాత్రమే బేర్ ఫార్వర్డ్ మరియు బ్యాక్‌వర్డ్ పాస్ కంటే 30 నుండి 100 శాతం అదనంగా ఉంటుంది, కాబట్టి ఇవి కేవలం వెయిట్స్-మాత్రమే గణాంకాలు కావు.

బ్యాచ్ 8 వద్ద పది నుండి పదహారు గిగాబైట్లు అనేది వాదన: 24 GB కార్డ్ దానికి అదనంగా డేటాలోడర్‌ను కూడా సరిపోతుంది. AY-Robots SmolVLAను RTX 4090 లేదా ఏదైనా 24 GB కార్డ్‌లో ఉంచుతుంది, కనీసం 30 ఎపిసోడ్‌లు, LeRobot v3.0 డేటా, ప్రతి యాక్షన్ స్టెప్‌కు 245 ms. అద్దెకు తీసుకుంటే, అది గంటకు 0.30 నుండి 0.60 USD చొప్పున 2 నుండి 5 గంటలు, సుమారు 1 నుండి 3 USD ఒక ఫైన్-ట్యూనింగ్ రన్, 80 GB టైర్ GR00T మరియు Pi0.5కి అవసరమైన 4 నుండి 12 USDతో పోలిస్తే (ధర). విఫలమైన SmolVLA రన్ ఒక కాఫీ; విఫలమైన GR00T రన్, లంచ్.

దశ 0: డేటాసెట్ రన్‌ను నిర్ణయిస్తుంది, ఫ్లాగ్‌లు కాదు

రికార్డింగ్ చెడ్డదైతే కింద ఉన్నదేదీ ముఖ్యం కాదు. LeRobot SmolVLA పేజీ స్పష్టంగా చెబుతుంది: రిఫరెన్స్ డేటాసెట్ 5 క్యూబ్ స్థానాల్లో 50 ఎపిసోడ్‌లు, ఒక్కో స్థానానికి 10, మరియు 25 ఎపిసోడ్‌లలో అదే పని సరిగా చేయలేదు. ప్రతి వైవిధ్యానికి పునరావృతం సాధారణీకరిస్తుంది, ముడి ఎపిసోడ్ సంఖ్య కాదు. ఎప్పుడూ రికార్డ్ చేయలేదా? ఇక్కడ ప్రారంభించండి మీ మొదటి డేటాసెట్‌ను రికార్డ్ చేయండి తో డెస్క్‌టాప్ క్లయింట్, ఇది ఒక టెలిఆపరేషన్ సెషన్ నుండి LeRobot ఫార్మాట్‌ను వ్రాస్తుంది, లేదా డేటాసెట్ డైరెక్టరీ నుండి ఒకదాన్ని తీసుకోండి.

• AY-Robotsలో కనీసం 30 ఎపిసోడ్‌లు, LeRobot రిఫరెన్స్ రెసిపీ కోసం సుమారు 50.
• రోల్‌అవుట్ సమయంలో మీరు ఆశించే ప్రతి వైవిధ్యం, అనేక సార్లు పునరావృతం చేయబడింది.
• ఒక టాస్క్ స్ట్రింగ్, రికార్డ్ మరియు రోల్‌అవుట్ సమయంలో ఒకే విధంగా స్పెల్లింగ్ చేయబడింది. మోడల్ ఆ టెక్స్ట్‌పై ఆధారపడి ఉంటుంది.
• స్థిర కెమెరాలు. రికార్డింగ్ మరియు రోల్‌అవుట్ మధ్య కదిలిన కెమెరా, క్లీన్ లాస్ కర్వ్ కదలిక లేని చేతిని ఇవ్వడానికి అత్యంత సాధారణ కారణం.
• మీరు ఎప్పుడూ శిక్షణ ఇవ్వని ఒక హెల్డ్-అవుట్ వైవిధ్యం, కాబట్టి మీరు నిజాయితీగా పరీక్షించడానికి ఏదైనా ఉంటుంది.

# 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

దీని గురించి మరింత సమాచారం అధిక నాణ్యత గల VLA శిక్షణ డేటాను ఎలా సేకరించాలి. సంక్షిప్త వెర్షన్: ఉద్దేశపూర్వక వైవిధ్యంతో ఒక పనికి సంబంధించిన 30 నుండి 50 క్లీన్ ఎపిసోడ్‌లు, మూడు పనులకు సంబంధించిన 200 అస్తవ్యస్తమైన ఎపిసోడ్‌లను ఓడిస్తాయి, ఏ హైపర్‌పారామీటర్ కూడా పూడ్చలేని తేడాతో.

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

బేస్ lerobot ఇన్‌స్టాల్ సన్నగా ఉంటుంది మరియు భారీ డిపెండెన్సీలను ఎక్స్‌ట్రాల వెనుక ఉంచుతుంది: smolvla ట్రాన్స్‌ఫార్మర్‌లు, num2words మరియు accelerate లను జోడిస్తుంది, training డేటాసెట్ స్టాక్ మరియు wandb, core_scripts హార్డ్‌వేర్ మరియు విజువలైజేషన్ డిపెండెన్సీలు. Linuxలో ఇన్‌స్టాల్ మార్గం మీ CUDA వీల్‌ను కూడా నిర్ణయిస్తుంది: PyPI డిఫాల్ట్ 580.65 డ్రైవర్ ఫ్లోర్‌తో కూడిన cu130 వీల్, కాబట్టి పాత డ్రైవర్‌లో ముందుగా cu128 ఇండెక్స్ నుండి టార్చ్‌ను ఇన్‌స్టాల్ చేయండి, ఆపై lerobot.

శిక్షణ అమలు, కమాండ్ ద్వారా కమాండ్

1. 1
   హబ్‌కు వ్యతిరేకంగా ప్రామాణీకరించండి

   బేస్ చెక్‌పాయింట్ హబ్ నుండి వస్తుంది, మరియు మీ డేటాసెట్ కూడా అక్కడి నుండే వస్తుంది.

   bash

   hf auth login

2. 2
   ఎంపికలను ఒకసారి చదవండి

   పైప్‌లైన్ మరియు పాలసీ కాన్ఫిగ్ యొక్క ప్రతి ఫీల్డ్ ఒక ఫ్లాగ్. సోర్స్‌లోకి వెళ్ళే ముందు ఒకసారి పరిశీలించండి.

   bash

   lerobot-train --help

3. 3
   ఫైన్-ట్యూన్‌ను ప్రారంభించండి

   డాక్స్ ఉదాహరణ ఒకే A100లో బ్యాచ్ 64ను నడుపుతుంది; కంప్యూట్ గైడ్ యొక్క A100 40 GB యాంకర్ బ్యాచ్ 16, మరియు 8 అనేది 24 GBకి సమానం. ఇక్కడ షెడ్యూలర్ ఫ్లాగ్ ఉద్దేశపూర్వకంగా లేదు, క్రింద చూడండి.

   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
   లాగ్ లైన్‌ను చదవండి, కేవలం లాస్‌ను కాదు

   ప్రతి --log_freq స్టెప్‌లకు lerobot loss, grdn, lr, updt_s, data_s, smp/s మరియు CUDAలో mem_gbలను ప్రింట్ చేస్తుంది. mem_gb బ్యాచ్ సరిపోతుందో లేదో చెబుతుంది, lr షెడ్యూల్ క్షీణిస్తుందో లేదో చెబుతుంది, మరియు data_s updt_sకి చేరుకోవడం అంటే డేటాలోడర్ బాటిల్‌నెక్, GPU కాదు అని అర్థం.

   bash

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

5. 5
   మీరు పోల్చగల చెక్‌పాయింట్‌లను సేకరించండి

   save_freq డిఫాల్ట్‌గా 20000, కాబట్టి 20000 స్టెప్ రన్ ఒక చెక్‌పాయింట్‌ను వదిలివేస్తుంది మరియు పోల్చడానికి ఏమీ ఉండదు. 2000కి సెట్ చేయండి. హబ్‌కు పుష్ చేయడానికి --policy.repo_id అవసరం.

   bash

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

6. 6
   యంత్రం ఆగిపోతే పునఃప్రారంభించండి

   చెక్‌పాయింట్ పక్కన ఉన్న train_config.json వద్ద --config_pathను సూచించండి. మీరు పునఃప్రారంభించకపోతే lerobot ఇప్పటికే ఉన్న output_dirలోకి ప్రారంభించడానికి నిరాకరిస్తుంది, కాబట్టి మీరు అనుకోకుండా ఒక రన్‌ను ఓవర్‌రైట్ చేయలేరు.

   bash

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

ఫలితాన్ని వాస్తవంగా మార్చే ఫ్లాగ్‌లు

మీరు ఏమీ మార్చకపోతే మీకు లభించే డిఫాల్ట్‌లు

ఒక పాలసీ కాన్ఫిగ్ lerobotలో దాని స్వంత ఆప్టిమైజర్ మరియు షెడ్యూలర్ ప్రీసెట్‌ను కలిగి ఉంటుంది, మరియు మీరు సెట్ చేయకపోతే use_policy_training_preset=false ఆ ప్రీసెట్‌లు గెలుస్తాయి. SmolVLA శిక్షణ గురించి ప్రజలు అడిగే ప్రశ్నలలో సగం, వారికి తెలియని డిఫాల్ట్ ద్వారా సమాధానం ఇవ్వబడతాయి.

ప్రజలను ఆశ్చర్యపరిచే రెండు పంక్తులు freeze_vision_encoder మరియు train_expert_only, రెండూ నిజం. సాధారణంగా మీరు సుమారు 100 M పారామీటర్‌లను శిక్షణ ఇస్తారు, 450 M కాదు, అందుకే ఇది 24 GBకి సరిపోతుంది. నాలుగు-GPU H100 క్లస్టర్‌పై LeRobot యొక్క స్వంత రిఫరెన్స్ రన్ రెండింటినీ తప్పుగా మారుస్తుంది; ఒక 24 GB కార్డ్‌లో అది పని చేసే రన్‌ను మెమరీ లేని క్రాష్.

రన్ ఎంత సమయం పడుతుంది మరియు ఎన్ని స్టెప్‌లు సరిపోతాయి

LeRobot సుమారు 50 ఎపిసోడ్‌ల డేటాసెట్‌పై ఐదు ఎపోచ్‌లకు వాల్-క్లాక్ యాంకర్‌లను ప్రచురిస్తుంది, ఇది 30 fps వద్ద సుమారు 45000 ఫ్రేమ్‌లు. డాక్యుమెంట్‌లు చెప్పినట్లుగా, ఇవి ఆర్డర్ ఆఫ్ మాగ్నిట్యూడ్ అంకెలు, కానీ అవి ఒక గంట మరియు ఒక రోజు మధ్య తేడాను సూచిస్తాయి.

ఫైన్-ట్యూన్ చేయబడిన పాలసీని తిరిగి ఆర్మ్‌పై అమలు చేయడం

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

ప్రతి చర్య దశకు 245 ms ను తప్పుగా అర్థం చేసుకోవడం సులభం: పాలసీ chunk_size = 50 ఫార్వర్డ్ పాస్‌కు చర్యలను విడుదల చేస్తుంది మరియు వాటిలో n_action_steps = 50 ను అమలు చేస్తుంది, కాబట్టి మీరు ఆ ఖర్చును ఎంత తరచుగా చెల్లిస్తారనేది ఆ నాబ్‌ల ద్వారా నిర్ణయించబడుతుంది, సర్వోలు ఎంత తరచుగా ఆదేశాన్ని పొందుతాయి అనే దాని ద్వారా కాదు. అదే చర్యల చంకింగ్ కొనుగోలు చేస్తుంది, మరియు 245 ms మోడల్ 30 Hz ఆర్మ్‌ను ఎందుకు నడపగలదు. మిగిలింది చంక్ చివరిలో ఇన్‌ఫరెన్స్ లేటెన్సీ.

ఆ మూడవ వరుసను చాలా వ్రాతలు దాటవేస్తాయి. అసింక్రోనస్ ఇన్‌ఫరెన్స్ సుమారు 30 శాతం వేగంగా ఉంటుంది మరియు నిర్ణీత విండోలో థ్రూపుట్‌ను సుమారుగా రెట్టింపు చేస్తుంది, మరియు పేపర్ విజయ రేట్లను పోల్చదగినవిగా పేర్కొంది, సగటున అవి అలాగే ఉన్నాయి. దాని కింద, సార్టింగ్ 70 నుండి 50 శాతానికి పడిపోయింది, అయితే పిక్ అండ్ ప్లేస్ 5 పెరిగింది. lerobot 0.6.1 అదే బైనరీలో మరొక లివర్‌ను కలిగి ఉంది: --inference.type=rtc రోల్‌అవుట్‌ను రియల్ టైమ్ చంకింగ్‌కు మారుస్తుంది, ఇది స్క్రిప్ట్ యొక్క స్వంత వినియోగ బ్లాక్ నెమ్మదిగా ఉండే VLAs, Pi0, Pi0.5 మరియు SmolVLA కోసం సిఫార్సు చేస్తుంది.

ఒకే చెక్‌పాయింట్‌కు రెండు మార్గాలు

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

SmolVLA తప్పు ఎంపిక అయినప్పుడు

స్మోల్‌వీఎల్‌ఏ సరైన మొదటి రన్ అవునా కాదా అని పరీక్షించడానికి, అది పనిచేసిందా లేదా అనేది కాదు, వైఫల్యం మీకు ఏదైనా చెప్పిందా అనేది ముఖ్యం. 60 లేదా 70 శాతం చేరుకుంటే, పెద్ద మోడల్‌పై తదుపరి ఖర్చు చేయడం సహేతుకం: డేటాలో సిగ్నల్ ఉంది. 10 శాతం చేరుకుంటే, 3 B మోడల్ కూడా 10 శాతం చేరుకునే అవకాశం ఉంది, దీనిని మీరు పన్నెండు డాలర్లకు బదులుగా మూడు డాలర్లకే తెలుసుకున్నారు.

మరింత ఖర్చు చేసే ముందు చదవదగినవి: Pi0.5 వర్సెస్ స్మోల్‌వీఎల్‌ఏ అదే ఆలోచనపై మరింత సామర్థ్యం కోసం, మరియు GR00T N1.7 వర్సెస్ స్మోల్‌వీఎల్‌ఏ NVIDIA మార్గం కోసం, రెండూ 80 GB శ్రేణిలో ఒక్కో రన్‌కు 4 నుండి 12 USD. మరో మార్గం, ACT చౌకైన బేస్‌లైన్: 80 M పారామీటర్లు, ఒక్కో చర్య దశకు 20 ms, భాషా కండిషనింగ్ లేదు. ఈ ఐదు కూడా ఇక్కడ ఉన్నాయి: పాలసీల పేజీ; అరేనా 85 మోడల్‌లు మరియు 332 బెంచ్‌మార్క్ ఫలితాలను కలిగి ఉంది.

ఏదైనా స్కేల్ చేయడానికి ముందు తనిఖీ జాబితా

1. lr దాని 2.5e-6 కనిష్ట స్థాయికి చేరుకుందా? 30000 స్టెప్‌ల కంటే తక్కువ ఉంటే, lerobot క్షీణతను తిరిగి స్కేల్ చేస్తుంది మరియు స్టార్టప్‌లో అలా చెబుతుంది; దాని పైన, --policy.scheduler_decay_stepsని మీరే సెట్ చేయండి.
2. ఒకటి కంటే ఎక్కువ చెక్‌పాయింట్‌లు, మరియు --dataset.eval_splitతో ఎపిసోడ్‌లు నిలిపివేయబడ్డాయి, తద్వారా మూల్యాంకన నష్టం ఏదైనా అర్థాన్ని కలిగి ఉంటుంది.
3. పాలసీ అస్సలు కదులుతుందా? కదలిక లేని చేయితో నష్టం తగ్గడం నిర్దిష్ట కారణాలను కలిగి ఉంది: నష్టం తగ్గుతుంది, పాలసీ ఏమీ చేయదు.
4. ఇది దృశ్యం మారినప్పుడు నిలబడుతుందా? లేకపోతే: పాలసీ ఒకే సెటప్‌లో మాత్రమే పనిచేస్తుంది.
5. మీరు సీడ్‌ను రాసుకున్నారా? lerobot డిఫాల్ట్‌గా 1000కి సెట్ చేయబడింది, కాబట్టి రెండు మార్పులేని రన్‌లు పోల్చదగినవిగా ఉంటాయి.
6. అప్పుడు మాత్రమే: మరిన్ని ఎపిసోడ్‌లు, మరిన్ని వైవిధ్యాలు లేదా పెద్ద మోడల్. ఆ క్రమంలో.

ఈ మోడల్‌లు ఎందుకు ఉనికిలో ఉన్నాయి మరియు భాషా ఇన్‌పుట్‌తో అవి ఏమి చేస్తాయి అనే దాని కోసం, అనేది నేపథ్యం; అసెంబ్లీని దీని ద్వారా నడుపుతుంది మొదటి రన్ వరకు. పూర్తయిన చెక్‌పాయింట్ కోసం, ; చేయి ఎప్పుడూ కనిపించకపోతే, .