SmolVLA को 24 GB GPU पर कैसे प्रशिक्षित करें (lerobot 0.6.1)

अधिकांश लोग जो एक विजन लैंग्वेज एक्शन मॉडल को एक वास्तविक आर्म पर चाहते हैं, वे हार्डवेयर लाइन पर रुक जाते हैं। GR00T N1.7 और Pi0.5 प्रत्येक लगभग तीन बिलियन पैरामीटर के हैं और उन्हें एक A100 80 GB या एक H100 की आवश्यकता होती है। यदि आपके पास RTX 4090 वाला एक गेमिंग पीसी है, तो यह यहीं समाप्त हो जाता है। स्मॉलवीएलए (SmolVLA) इसका अपवाद है: 450 M पैरामीटर, लेरोबोट (LeRobot) के भीतर, जिसे एक उपभोक्ता कार्ड पर फाइन-ट्यून करने और सीपीयू (CPU) से सेवा देने के लिए बनाया गया है।

पहले मैन्युअल तरीका: लेरोबोट (lerobot) इंस्टॉल करें, 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 है, जहाँ एसीटी प्रति कार्य प्रशिक्षित का औसत 48.3 था। वही पंक्तियाँ हर प्रकाशित वीएलए के बगल में हैं स्मॉलवीएलए एरिना एंट्री और एसीटी बनाम स्मॉलवीएलए तुलना।

24 GB कार्ड पहली बार चलाने के लिए सही क्यों है

LeRobot इस काम के लिए एक कंप्यूट साइज़िंग गाइड प्रदान करता है, जो रेपो में सबसे उपयोगी पेज है। यह नीतियों को बैकबोन साइज़ के अनुसार समूहित करता है और प्रति समूह एक VRAM एनवेलप देता है, जिसे बैच साइज़ 8 पर AdamW (जो 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 लापरवाह एपिसोड को हरा देते हैं, इतने बड़े अंतर से जिसे कोई हाइपरपैरामीटर बंद नहीं कर सकता।

लेरोबोट 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

मूल लेरोबोट इंस्टाल पतला है और भारी निर्भरताओं को एक्स्ट्रा के पीछे रखता है: स्मोलवीएलए ट्रांसफॉर्मर, num2words और एक्सेलेरेट जोड़ता है, ट्रेनिंग डेटासेट स्टैक और wandb, कोर_स्क्रिप्ट्स हार्डवेयर और विज़ुअलाइज़ेशन निर्भरताएँ। लिनक्स पर इंस्टाल पाथ आपके CUDA व्हील को भी तय करता है: PyPI डिफ़ॉल्ट 580.65 के ड्राइवर फ्लोर के साथ एक cu130 व्हील है, इसलिए पुराने ड्राइवर पर पहले cu128 इंडेक्स से टॉर्च इंस्टॉल करें, फिर लेरोबोट।

प्रशिक्षण रन, कमांड दर कमांड

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 स्टेप्स पर लेरोबोट लॉस, 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 को इंगित करें। लेरोबोट मौजूदा output_dir में शुरू होने से मना कर देता है जब तक कि आप फिर से शुरू नहीं कर रहे हों, इसलिए आप गलती से किसी रन को ओवरराइट नहीं कर सकते।

   bash

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

वे फ़्लैग जो वास्तव में परिणाम बदलते हैं

यदि आप कुछ भी नहीं छूते हैं तो आपको मिलने वाले डिफ़ॉल्ट

एक पॉलिसी कॉन्फ़िग लेरोबोट में अपना ऑप्टिमाइज़र और शेड्यूलर प्रीसेट रखता है, और जब तक आप सेट नहीं करते use_policy_training_preset=false तब तक वे प्रीसेट जीतते हैं। SmolVLA प्रशिक्षण के बारे में लोग जो आधे सवाल पूछते हैं, उनका जवाब एक ऐसे डिफ़ॉल्ट से मिलता है जिसके बारे में उन्हें पता नहीं था।

दो लाइनें जो लोगों को आश्चर्यचकित करती हैं वे हैं freeze_vision_encoder और train_expert_only, दोनों सही हैं। बिना किसी बदलाव के आप लगभग 100 M पैरामीटर प्रशिक्षित करते हैं, 450 M नहीं, यही कारण है कि यह 24 GB पर फिट बैठता है। LeRobot का चार-GPU H100 क्लस्टर पर अपना संदर्भ रन दोनों को गलत कर देता है; एक 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 मिलीसेकंड को गलत समझना आसान है: पॉलिसी प्रति फॉरवर्ड पास chunk_size = 50 एक्शन उत्सर्जित करती है और उनमें से n_action_steps = 50 को निष्पादित करती है, इसलिए आपको वह लागत कितनी बार चुकानी पड़ती है, यह उन नॉब्स द्वारा निर्धारित होता है, न कि इस बात से कि सर्वो को कितनी बार कमांड मिलती है। यही वह है जो एक्शन चंकिंग प्रदान करता है, और यही कारण है कि 245 मिलीसेकंड का मॉडल 30 हर्ट्ज की आर्म को चला सकता है। जो बचा है वह चंक के अंत में इन्फरेंस लेटेंसी है।

वह तीसरी पंक्ति है जिसे अधिकांश लेख छोड़ देते हैं। असिंक्रोनस इन्फरेंस लगभग 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 गलत विकल्प हो

SmolVLA सही पहली रन थी या नहीं, इसकी कसौटी यह नहीं है कि यह काम कर गई, बल्कि यह है कि विफलता ने आपको कुछ बताया या नहीं। 60 या 70 प्रतिशत तक पहुँचने पर एक बड़ा मॉडल अगला उचित खर्च है: डेटा में संकेत होता है। 10 प्रतिशत तक पहुँचने पर एक 3 B मॉडल भी संभवतः 10 प्रतिशत तक पहुँचता है, जो आपने बारह डॉलर के बजाय तीन डॉलर में सीख लिया।

अधिक खर्च करने से पहले पढ़ने लायक: Pi0.5 against SmolVLA उसी विचार पर अधिक क्षमता के लिए, और GR00T N1.7 against SmolVLA 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. तभी: अधिक एपिसोड, अधिक भिन्नता, या एक बड़ा मॉडल। इसी क्रम में।

ये मॉडल क्यों मौजूद हैं और वे भाषा इनपुट के साथ क्या करते हैं, इसके लिए, पृष्ठभूमि है; असेंबली को से पहले रन तक चलाता है। समाप्त चेकपॉइंट के लिए, ; यदि हाथ कभी दिखाई नहीं देता है, तो ।