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 म्हणजे काय, तुम्ही तपासू शकता अशा संख्यांमध्ये

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 प्रति टास्क प्रशिक्षित 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 हार्डवेअर आणि व्हिज्युअलायझेशन डिपेंडन्सीज जोडते. लिनक्सवर इन्स्टॉल पाथ तुमच्या CUDA व्हीलची निवड देखील ठरवतो: PyPI डीफॉल्ट cu130 व्हील आहे ज्यासाठी ड्रायव्हरची किमान आवृत्ती 580.65 आहे, त्यामुळे जुन्या ड्रायव्हरवर आधी 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 लॉस, 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 मध्ये बसते. 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 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 चुकीची निवड असते

SmolVLA योग्य पहिली चाचणी होती की नाही हे ते यशस्वी झाले की नाही यावर अवलंबून नाही, तर त्या अपयशातून तुम्हाला काही शिकायला मिळाले का यावर अवलंबून आहे. 60 किंवा 70 टक्के गाठल्यास, एक मोठा मॉडेल पुढील योग्य खर्च आहे: डेटा सिग्नल देतो. 10 टक्के गाठल्यास, 3 B मॉडेल देखील बहुधा 10 टक्के गाठेल, जे तुम्ही बारा डॉलर्सऐवजी तीन डॉलर्समध्ये शिकलात.

अधिक खर्च करण्यापूर्वी वाचण्यासारखे: Pi0.5 विरुद्ध SmolVLA त्याच कल्पनेवर अधिक क्षमतेसाठी, आणि GR00T N1.7 विरुद्ध 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. धोरण (policy) अजिबात हलते का? स्थिर हाताने कमी होणाऱ्या लॉसची विशिष्ट कारणे आहेत: लॉस कमी होतो, धोरण काहीही करत नाही.
4. ते दृश्यातील बदलातून टिकून राहते का? नसल्यास: धोरण (policy) फक्त एकाच सेटअपमध्ये कार्य करते.
5. तुम्ही सीड (seed) लिहून ठेवले आहे का? lerobot डीफॉल्टनुसार 1000 वापरतो, त्यामुळे दोन न बदललेले रन तुलना करण्यायोग्य राहतात.
6. फक्त त्यानंतर: अधिक एपिसोड्स, अधिक विविधता किंवा मोठे मॉडेल. याच क्रमाने.

हे मॉडेल्स का अस्तित्वात आहेत आणि भाषिक इनपुटसह ते काय करतात, यासाठी, , ही पार्श्वभूमी आहे; असेंब्ली चालवते ते पहिल्या रनपर्यंत. पूर्ण झालेल्या चेकपॉइंटसाठी, ; जर आर्म कधीच दिसला नाही, तर, .