24 GB GPU मा SmolVLA लाई कसरी तालिम दिने (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 हो; शोधपत्रले यसको भाषा मोडेलका पहिलो १६ तहहरू मात्र राखेको छ, प्रत्येक क्यामेरा फ्रेमलाई इमेज टाइलिङको सट्टा पिक्सेल शफलको साथ ६४ भिजुअल टोकनमा सीमित गर्दछ, र प्रत्येक दोस्रो ब्लकमा सेल्फ एटेन्सन लेयरसँग क्रस एटेन्सनलाई अन्तर-मिश्रित गर्दछ। इन्फरेन्स लागत डिजाइनको एक बाधा थियो, न कि पछि सोचिएको कुरा।

बेन्चमार्कहरू नै कारण हुन् जसले गर्दा मानिसहरू 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 थियो। उही पङ्क्तिहरू SmolVLA एरेना प्रविष्टि र ACT बनाम SmolVLA तुलना मा प्रकाशित प्रत्येक VLA सँगै छन्।

२४ GB कार्ड किन पहिलो रनको लागि सही छ

LeRobot ले यसका लागि रिपोमा सबैभन्दा उपयोगी पृष्ठ, कम्प्युट साइजिंग गाइड प्रदान गर्दछ। यसले नीतिहरूलाई ब्याकबोन साइज अनुसार समूहबद्ध गर्दछ र प्रत्येक समूहको लागि एक VRAM इन्भेलप दिन्छ, जुन AdamW, lerobot को पूर्वनिर्धारित सेटिङ, प्रयोग गरी ब्याच साइज 8 मा मापन गरिएको हो। अप्टिमाइजरको अवस्थाले मात्र सामान्य फर्वार्ड र ब्याकवर्ड पास भन्दा ३० देखि १०० प्रतिशत थप गर्दछ, त्यसैले यी केवल वजन-मात्रका आंकडाहरू होइनन्।

ब्याच 8 मा दश देखि सोह्र गिगाबाइटको तर्क छ: २४ GB कार्डले त्यो र डेटालोडर दुवैलाई समेट्छ। AY-Robots ले SmolVLA लाई RTX 4090 वा कुनै पनि २४ GB कार्डमा राख्छ, न्यूनतम ३० एपिसोडहरू, LeRobot v3.0 डेटा, प्रति कार्य चरणमा २४५ ms। भाडामा लिँदा, त्यो प्रति घण्टा ०.३० देखि ०.६० USD मा २ देखि ५ घण्टा हुन्छ, लगभग १ देखि ३ USD प्रति फाइन-ट्यूनिङ रन, ८० GB टियर GR00T र Pi0.5 लाई चाहिने ४ देखि १२ USD को तुलनामा (मूल्य निर्धारण)। असफल SmolVLA रन कफी बराबर हो; असफल GR00T रन लन्च बराबर हो।

चरण 0: डेटासेटले रनको निर्णय गर्छ, फ्ल्यागहरूले होइन

रेकर्डिङ खराब भएमा तलका कुनै पनि कुराले फरक पार्दैन। LeRobot SmolVLA पृष्ठ स्पष्ट छ: सन्दर्भ डेटासेट 5 घन स्थितिहरूमा 50 एपिसोडहरू थियो, प्रति स्थिति 10, र 25 एपिसोडहरूमा समान कार्य खराब प्रदर्शन गर्‍यो। भिन्नता अनुसारको पुनरावृत्तिले सामान्यीकरण गर्छ, कच्चा एपिसोड गणनाले गर्दैन। कहिल्यै रेकर्ड गर्नुभएको छैन? यहाँबाट सुरु गर्नुहोस् आफ्नो पहिलो डेटासेट रेकर्ड गर्नुहोस्, सँग डेस्कटप क्लाइन्ट, जसले टेलिओपरेशन सत्रबाट LeRobot ढाँचामा लेख्छ, वा डेटासेट डाइरेक्टरी बाट एउटा लिनुहोस्।

• AY-Robots मा कम्तिमा ३० एपिसोडहरू, LeRobot सन्दर्भ रेसिपीका लागि लगभग ५०।
• रोलआउटमा तपाईंले अपेक्षा गर्ने हरेक भिन्नता, धेरै पटक दोहोर्याइएको।
• एउटा कार्य स्ट्रिङ, रेकर्ड र रोलआउट समयमा समान रूपमा लेखिएको। मोडेल त्यो पाठमा आधारित हुन्छ।
• स्थिर क्यामेराहरू। रेकर्डिङ र रोलआउटको बीचमा सारिएको क्यामेरा नै सफा लस कर्भले गतिहीन हात दिने सबैभन्दा सामान्य कारण हो।
• एउटा होल्ड-आउट भिन्नता जुन तपाईंले कहिल्यै तालिम दिनुभएन, ताकि तपाईंसँग परीक्षण गर्नको लागि केही इमानदार होस्।

# 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 प्रशिक्षण डेटा कसरी सङ्कलन गर्ने मा। छोटो संस्करण: जानाबुझी भिन्नताका साथ एउटै कार्यका ३० देखि ५० सफा एपिसोडहरूले तीनवटा कार्यका २०० लापरवाह एपिसोडहरूलाई हराउँछन्, यस्तो मार्जिनले कुनै पनि हाइपरप्यारामिटरले बन्द गर्दैन।

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 इन्डेक्सबाट torch स्थापना गर्नुहोस्, त्यसपछि 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 मा फिट हुन्छ। 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 सही पहिलो रन थियो कि थिएन भन्ने परीक्षण यो सफल भयो कि भएन भन्ने होइन, तर असफलताले तपाईंलाई केही बतायो कि बताएन भन्ने हो। ६० वा ७० प्रतिशतमा पुग्नुभयो भने ठूलो मोडेल अर्को उचित खर्च हो: डेटाले संकेत बोक्छ। १० प्रतिशतमा पुग्नुभयो भने ३ B मोडेल पनि १० प्रतिशतमा पुग्ने सम्भावना बढी हुन्छ, जुन तपाईंले बाह्र डलरको सट्टा तीन डलरमा सिक्नुभयो।

थप खर्च गर्नु अघि पढ्न लायक: Pi0.5 SmolVLA विरुद्ध एउटै विचारमा थप क्षमताका लागि, र GR00T N1.7 SmolVLA विरुद्ध NVIDIA मार्गका लागि, दुवै ८० GB टियर प्रति रन ४ देखि १२ USD मा। अर्को तरिका, ACT सस्तो आधारभूत हो: ८० M प्यारामिटरहरू, प्रति कार्य चरण २० ms, कुनै भाषा कन्डिसनिङ छैन। सबै पाँचवटा यहाँ छन् नीति पृष्ठ; एरिना सँग ८५ मोडेल र ३३२ बेन्चमार्क परिणामहरू छन्।

कुनै पनि कुरा मापन गर्नु अघिको चेकलिस्ट

1. के lr यसको 2.5e-6 न्यूनतम बिन्दुमा पुग्यो? 30000 स्टेप्स भन्दा कममा lerobot ले क्षयलाई पुनः मापन गर्छ र स्टार्टअपमा त्यसो भन्छ; त्यो भन्दा माथि, --policy.scheduler_decay_steps आफैं सेट गर्नुहोस्।
2. एक भन्दा बढी चेकपोइन्ट, र --dataset.eval_split सँग राखिएका एपिसोडहरू ताकि मूल्याङ्कन हानि (eval loss) को केही अर्थ होस्।
3. के नीति (policy) अलिकति पनि चल्छ? गतिहीन हातको साथ घट्दो हानि (falling loss) का विशेष कारणहरू छन्: हानि घट्छ, नीतिले केही गर्दैन।
4. के यसले दृश्य परिवर्तनमा पनि काम गर्छ? यदि गर्दैन भने: नीतिले एउटै सेटअपमा मात्र काम गर्छ।
5. के तपाईंले सीड (seed) लेख्नुभयो? lerobot पूर्वनिर्धारित रूपमा 1000 मा सेट हुन्छ, त्यसैले दुई अपरिवर्तित रनहरू तुलनायोग्य रहन्छन्।
6. त्यसपछि मात्र: थप एपिसोडहरू, थप भिन्नता, वा ठूलो मोडेल। त्यसै क्रममा।

यी मोडेलहरू किन अवस्थित छन् र भाषा इनपुटसँग तिनीहरूले के गर्छन् भन्ने बारेमा, पृष्ठभूमि हो; ले एसेम्बली चलाउँछ देखि पहिलो रनमा। समाप्त चेकपोइन्टको लागि, ; यदि हात कहिल्यै देखा पर्दैन भने, ।