अपने रोबोट डेटा पर Pi0.5 को कैसे प्रशिक्षित करें

Pi0.5 वह मॉडल है जिसका उपयोग आप तब करते हैं जब किसी नीति को ऐसे कमरे में काम करना होता है जिसे उसने पहले कभी नहीं देखा है। यह पाँच में से सबसे अजीब भी है प्रशिक्षित करने योग्य नीतियाँ यहाँ फाइन-ट्यून हाथ से करने के लिए: अपस्ट्रीम रिपॉजिटरी पहले JAX है, LeRobot पोर्ट ने 0.6.0 में lerobot-record से डिप्लॉयमेंट को बाहर कर दिया और बेस इंस्टाल को प्रशिक्षण के लिए बहुत छोटा बना दिया, और एक पूर्ण फाइन-ट्यून 4090 पर फिट नहीं होता है। नीचे: फ्लो मैचिंग अनुमान पर क्या लागत आती है, दो कमांड मार्ग, और 485 ms की संख्या जो तय करती है कि परिणाम प्रयोग करने योग्य है या नहीं।

Pi0.5 वास्तव में क्या है

फिजिकल इंटेलिजेंस ने अक्टूबर 2024 में pi0 प्रकाशित किया: एक फ्लो मैचिंग विजन-लैंग्वेज-एक्शन मॉडल एक प्रीट्रेन्ड VLM पर: 3 बिलियन पैरामीटर वाला PaliGemma और स्क्रैच से इनिशियलाइज़ किया गया 300M एक्शन एक्सपर्ट, कुल 3.3 बिलियन। पेपर 7 रोबोट कॉन्फ़िगरेशन और 68 कार्यों में 10,000 घंटे से अधिक रोबोट डेटा पर प्री-ट्रेनिंग की रिपोर्ट करता है। अधिक जानकारी pi0 लेख में।

Pi0.5 (arXiv 2504.16054, 22 अप्रैल 2025) उस ढांचे को बरकरार रखता है और प्रशिक्षण आहार को बदलता है: वेब डेटा, वस्तु पहचान, रोबोट को प्रशिक्षित करने वाले मनुष्यों से मौखिक निर्देश, उपकार्य लेबल, कई घरों में रोबोट से क्रॉस-एम्बॉडीमेंट डेटा। इसका परिणाम यह है कि एक रोबोट उन घरों में रसोई की सफाई करता है जो प्रशिक्षण सेट में नहीं थे। openpi README एक विवरण जोड़ता है जो शीर्षक में नहीं है: जारी किया गया pi0.5 ज्ञान इन्सुलेशन (arXiv 2505.23705) के साथ प्रशिक्षित किया गया था।

फ्लो मैचिंग प्रशिक्षण और अनुमान के बारे में क्या बदलता है

एक पॉलिसी जिसे आप SO-100 पर प्रशिक्षित कर सकते हैं, या तो सीधे क्रियाओं को रिग्रेस करता है (ACT) या उन्हें टोकनाइज़ करता है और ऑटोरेग्रेसिव रूप से डिकोड करता है (pi0-FAST)। फ्लो मैचिंग इनमें से कोई भी नहीं करता है: यह एक वेक्टर फ़ील्ड सीखता है जो शोर को एक स्वच्छ एक्शन चंक, फिर उसे एकीकृत करता है। pi0 पेपर 0.1 के स्टेप साइज़ पर 10 इंटीग्रेशन स्टेप्स का उपयोग करता है; LeRobot का pi05 कॉन्फ़िग वही num_inference_steps: int = 10 वहन करता है।

• प्रशिक्षण: लॉस एक नॉइज़्ड एक्शन चंक को रिग्रेस करता है। ट्यून करने के लिए कोई टोकनाइज़र नहीं, आपके जॉइंट एंगल्स का कोई डिस्क्रीटाइज़ेशन नहीं।
• अनुमान: एक चंक में एक्शन एक्सपर्ट के माध्यम से दस फॉरवर्ड पास लगते हैं। यह संरचनात्मक है, ट्यूनिंग समस्या नहीं।
• आउटपुट: आयाम 32 की निरंतर क्रियाएं, आंतरिक रूप से पैडेड, आपके रोबोट के आयामों पर लिया गया लॉस। एक 6-DoF आर्म प्लस ग्रिपर 7 का उपयोग करता है।

# openpi/src/openpi/models/pi0_config.py - the defaults every pi05 config inherits
@dataclasses.dataclass(frozen=True)
class Pi0Config(_model.BaseModelConfig):
    dtype: str = "bfloat16"
    paligemma_variant: _gemma.Variant = "gemma_2b"
    action_expert_variant: _gemma.Variant = "gemma_300m"

    action_dim: int = 32
    action_horizon: int = 50
    max_token_len: int = None      # 200 if pi05 else 48

    pi05: bool = False             # flips discrete_state_input to True

पलिगेमा बैकबोन, और उसके सामने का गेट

PaliGemma (arXiv 2407.07726) एक Gemma-2B भाषा मॉडल पर आधारित SigLIP-So400m विजन एनकोडर है, जिसमें लगभग 3B पैरामीटर हैं। Pi0.5 अपने टोकेनाइज़र को इनहेरिट करता है, और वह टोकेनाइज़र एक गेटेड रिपॉजिटरी में रहता है। यह सबसे आम तरीका है जिससे पहली बार रन विफल होता है, पहले प्रशिक्षण चरण से भी पहले।

शुरू करने से पहले: डेटासेट प्रारूप, एपिसोड, हार्डवेयर

LeRobot में Pi0.5 एक LeRobot डेटासेट को v3.0 लेआउट में पढ़ता है, जो अक्टूबर 2025 में lerobot 0.4.0 के साथ आया था: प्रति Parquet और MP4 फ़ाइल में कई एपिसोड, प्रति एपिसोड के बजाय, meta/episodes/ में सीमाओं के साथ, फ़ाइलनामों में नहीं। डेस्कटॉप क्लाइंट के साथ रिकॉर्ड करें या अपना पहला डेटासेट रिकॉर्ड करें का अनुसरण करें और आपके पास यह होगा।

# v2.1 -> v3.0, run against a dataset already on the Hub
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=<HF_USER/DATASET_ID>

# aggregates episode-0000.parquet, episode-0001.parquet, ... -> file-0000.parquet
# aggregates episode-0000.mp4, episode-0001.mp4, ...         -> file-0000.mp4
# rewrites meta/episodes/* with per-episode lengths, tasks and offsets

प्लेटफ़ॉर्म को Pi0.5 के लिए कम से कम 50 एपिसोड चाहिए, जो GR00T और ACT के समान न्यूनतम सीमा है। प्री-ट्रेनिंग ही मुख्य काम करती है, इसलिए 50 साफ़-सुथरे एपिसोड 200 अव्यवस्थित एपिसोड से बेहतर होते हैं। इसमें नए हैं? शुरुआत करें डेटा संग्रह मार्गदर्शिका.

मार्ग A: openpi रिपॉजिटरी के साथ फाइन-ट्यून करें

संदर्भ कार्यान्वयन: पहले JAX, केवल Ubuntu 22.04 पर परीक्षण किया गया, फ्लैग के बजाय कॉन्फ़िग ऑब्जेक्ट्स द्वारा संचालित। सितंबर 2025 में एक PyTorch पाथ आया, जिसे LIBERO पर मान्य किया गया। तीन चरण: अपना डेटा परिवर्तित करें, एक कॉन्फ़िग परिभाषित करें, प्रशिक्षित करें और सेवा दें।

1. 1
   क्लोन करें और इंस्टॉल करें

   openpi uv का उपयोग करता है। GIT_LFS_SKIP_SMUDGE वह है जो LeRobot को LFS ब्लब्स के बिना एक निर्भरता के रूप में आने देता है।

   bash

   git clone --recurse-submodules git@github.com:Physical-Intelligence/openpi.git
   cd openpi
   
   GIT_LFS_SKIP_SMUDGE=1 uv sync
   GIT_LFS_SKIP_SMUDGE=1 uv pip install -e .

2. 2
   अपने डेटा को LeRobot डेटासेट में परिवर्तित करें

   अपस्ट्रीम LIBERO और DROID के लिए कन्वर्टर भेजता है और आपसे एक को अनुकूलित करने की अपेक्षा करता है। काम कुंजी मैपिंग है।

   bash

   uv run examples/libero/convert_libero_data_to_lerobot.py --data_dir /path/to/your/data

3. 3
   एक प्रशिक्षण कॉन्फ़िग जोड़ें

   कॉन्फ़िग src/openpi/training/config.py में TrainConfig प्रविष्टियाँ हैं। यह pi05_droid_finetune को अनुकूलित करता है, जिसमें वेट लोडर pi05_base की ओर इंगित करता है।

   python

   TrainConfig(
       name="pi05_so100",
       model=pi0_config.Pi0Config(
           pi05=True,
           action_dim=32,        # pi05 is trained with 32-dim actions
           action_horizon=16,
       ),
       # Copy LeRobotLiberoDataConfig in the same file and rewrite the key
       # mapping for your camera names, then reference your copy here.
       data=LeRobotLiberoDataConfig(
           repo_id="your_hf_username/my_so100_dataset",
           base_config=DataConfig(prompt_from_task=True),
       ),
       weight_loader=weight_loaders.CheckpointWeightLoader(
           "gs://openpi-assets/checkpoints/pi05_base/params"
       ),
       batch_size=32,
       num_train_steps=20_000,
   )

4. 4
   सामान्य आँकड़े गणना करें

   यह कॉन्फ़िग नाम के विरुद्ध चलता है, डेटासेट के विरुद्ध नहीं। इसे छोड़ना यहाँ की क्लासिक पहली विफलता है।

   bash

   uv run scripts/compute_norm_stats.py --config-name pi05_so100

5. 5
   प्रशिक्षित करें

   यह वेरिएबल JAX को डिफ़ॉल्ट 75 के बजाय GPU मेमोरी का 90 प्रतिशत उपयोग करने देता है। 80 GB कार्ड पर यह तय करता है कि रन जीवित रहेगा या नहीं।

   bash

   XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_so100 \
       --exp-name=my_experiment \
       --overwrite

6. 6
   इसे सेवा दें

   सर्वर पोर्ट 8000 पर सुनता है और अवलोकन प्रश्नों का उत्तर देता है; आपका रोबोट रनटाइम क्लाइंट है।

   bash

   uv run scripts/serve_policy.py policy:checkpoint \
       --policy.config=pi05_so100 \
       --policy.dir=checkpoints/pi05_so100/my_experiment/20000

मार्ग B: lerobot pi05 के साथ फाइन-ट्यून करें

LeRobot पोर्ट उन्हीं वेट्स को CLI में लपेटता है जिनका उपयोग आप पहले से ही ACT और SmolVLA के लिए करते हैं। नीचे दी गई सभी जानकारी lerobot 0.6.1 (3 अगस्त 2026 से जारी) और 23 अगस्त 2026 को pi05 डॉक्स के विरुद्ध जाँची गई थी। यहाँ संस्करण महत्वपूर्ण हैं: v3.0 डेटासेट अक्टूबर 2025 में 0.4.0 के साथ आए, 9 मार्च 2026 के 0.5.0 ब्लॉग में pi0-FAST और रियल-टाइम चंकिंग प्रस्तुत किया गया, और 6 जुलाई 2026 को 0.6.0 ने बेस पैकेज को हल्का बनाया और डिप्लॉयमेंट को lerobot-rollout में स्थानांतरित कर दिया।

एक चीज़ नहीं बदली: lerobot-train और lerobot-record अगस्त 2025 में 0.3.2 में पहले से ही एंट्री पॉइंट थे। एक ट्यूटोरियल जो अभी भी python -m lerobot.scripts.train को कॉल करता है, वह एक साल के बदलावों से पहले का है और बाकी जानकारी के लिए भी उस पर भरोसा नहीं किया जाना चाहिए।

1. 1
   सही एक्स्ट्रा के साथ इंस्टॉल करें

   0.6.0 के बाद से, बेस इंस्टॉल में केवल कोर एमएल डिपेंडेंसी होती हैं, और पाई एक्स्ट्रा कोई डेटासेट या ट्रेनिंग कोड नहीं जोड़ता है, इसलिए फाइन-ट्यून के लिए ट्रेनिंग एक्स्ट्रा की भी आवश्यकता होती है। पुराने वन-लाइनर यहां इम्पोर्ट के समय विफल हो जाते हैं।

   bash

   # policy dependencies plus the training stack
   pip install 'lerobot[pi,training]'
   
   # from a source checkout
   pip install -e ".[pi,training]"
   
   # driving an SO-100 afterwards needs the robot extras too
   pip install 'lerobot[core_scripts,feetech]'

2. 2
   प्रमाणीकरण करें

   एक ब्राउज़र में paligemma-3b-pt-224 लाइसेंस स्वीकार करें, फिर ट्रेनिंग करने वाली मशीन पर लॉग इन करें।

   bash

   hf auth login

3. 3
   क्वांटाइल सांख्यिकी जोड़ें

   Pi0.5, STATE और ACTION को क्वांटाइल के साथ सामान्य करता है, इसलिए meta/stats.json को q01 और q99 की आवश्यकता होती है। पुराने डेटासेट में केवल min, max, mean, std होते हैं।

   bash

   lerobot-edit-dataset \
       --repo_id your_dataset \
       --new_repo_id your_dataset \
       --operation.type recompute_stats \
       --operation.overwrite true

4. 4
   lerobot/pi05_base से फाइन-ट्यून करें

   बैच साइज़ को उतना सेट करें जितना आपका कार्ड संभाल सके; डॉक्स में LIBERO पर 80 GB के साथ 64 का उपयोग किया गया है। bfloat16 को स्पष्ट रूप से पास करें, कॉन्फ़िग डिफ़ॉल्ट float32 है।

   bash

   lerobot-train \
       --dataset.repo_id=${HF_USER}/my_so100_dataset \
       --policy.type=pi05 \
       --policy.pretrained_path=lerobot/pi05_base \
       --policy.gradient_checkpointing=true \
       --policy.dtype=bfloat16 \
       --policy.device=cuda \
       --policy.push_to_hub=false \
       --output_dir=./outputs/pi05_so100 \
       --job_name=pi05_so100 \
       --batch_size=4 \
       --num_workers=8 \
       --steps=30000 \
       --save_freq=5000 \
       --seed=1000

5. 5
   इसे आर्म पर चलाएं

   0.6.x में यह lerobot-rollout है: lerobot-record एक पॉलिसी को अस्वीकार करता है और eval_ डेटासेट नामों को खारिज करता है। बेस आर्म को चलाता है, सेंट्री रोलआउट को रिकॉर्ड करता है।

   bash

   lerobot-rollout \
       --strategy.type=base \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
       --task="Put lego brick into the transparent box" \
       --duration=60
   
   # same run, recorded into an eval_ dataset
   lerobot-rollout \
       --strategy.type=sentry \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --dataset.repo_id=${HF_USER}/eval_so100 \
       --dataset.single_task="Put lego brick into the transparent box" \
       --duration=600

डिफ़ॉल्ट के तीन सेट, और कौन से ट्रेनर तक पहुँचते हैं

openpi का TrainConfig संदर्भ है, LeRobot का PI05Config वह है जिसका उपयोग lerobot-train तब करता है जब आप कुछ नहीं कहते हैं, और यहां का फॉर्म एक तीसरा सेट भेजता है। आश्चर्य सीखने की दर है: दोनों अपस्ट्रीम डिफ़ॉल्ट 2.5e-5 पर चरम पर होते हैं, जबकि openpi का अपना pi05_libero कॉन्फ़िग और यह प्लेटफ़ॉर्म इसे 5e-5 तक बढ़ाता है।

क्या पोर्ट विश्वसनीय है? LeRobot टीम ने LIBERO बेस मॉडल को अतिरिक्त 6k चरणों के लिए फाइन-ट्यून किया और openpi के संदर्भ संख्याओं के साथ चार सुइट्स पर तुलना की: 96.85 के मुकाबले 97.5 प्रतिशत औसत, Libero 10 पर आगे, Spatial पर पीछे। यह मार्ग एक टूलिंग विकल्प है, गुणवत्ता का नहीं।

485 ms की वास्तविकता, और जहाँ यह अनुपयोगी हो जाता है

यह आपके प्रोजेक्ट का निर्धारण करता है, इसलिए यह लागत तालिका से पहले आता है। प्रति क्रिया चरण Pi0.5 के लिए यहाँ मापा गया 485 ms है। अन्य चार के मुकाबले:

अपस्ट्रीम के पास एक जवाब है, और इसका आधा हिस्सा पहले से ही उस रिलीज़ में है जिसे आप इंस्टॉल कर सकते हैं। रियल-टाइम चंकिंग अगले चंक को तब उत्पन्न करता है जब भुजा अभी भी वर्तमान वाले को निष्पादित कर रही होती है, फिर नए चंक के ओवरलैपिंग चरणों को पहले से निष्पादित भाग के करीब रहने के लिए मार्गदर्शन करता है, ताकि भुजा जोड़ पर रुके या झटके न। Pi0, Pi0.5 और SmolVLA के लिए 0.4.2 चेंजलॉग में शिप किया गया इन्फ्रेंस-टाइम फॉर्म एक रोलआउट फ्लैग है, न कि रिट्रेन:

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/my_policy \
    --inference.type=rtc \
    --inference.rtc.execution_horizon=10 \
    --inference.rtc.max_guidance_weight=10.0 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
    --task="Put lego brick into the transparent box" \
    --duration=60

यह मॉडल को तेज़ नहीं बनाता है। यह अंतर को छुपाता है: 485 मिलीसेकंड अभी भी खर्च होते हैं, लेकिन महत्वपूर्ण पथ से हटकर, ताकि चंक्स के बीच कतार खाली न हो। arXiv 2512.05964 से प्रशिक्षण-समय का संस्करण और आगे जाता है: मॉडल एक स्वच्छ एक्शन प्रीफिक्स पर कंडीशन करना सीखता है, इसलिए इन्फ्रेंस पर ओवरलैप को निर्देशित करने के बजाय प्रति-एक्शन फ्लो टाइमस्टेप्स के साथ हार्ड-इनपेंट किया जाता है, और मार्गदर्शन बैकवर्ड पास गायब हो जाता है। प्रशिक्षण के दौरान यह प्रति उदाहरण एक प्रीफिक्स लंबाई का नमूना लेता है और शेष पोस्टफिक्स पर फ्लो लॉस लेता है। वह फ्लैग केवल मुख्य पर रहता है, 0.6.1 में नहीं, और जिस देरी के लिए आप प्रशिक्षण देते हैं वह chunk_size से कम रहना चाहिए।

Pi0.5 चेकपॉइंट प्राप्त करने के दो तरीके

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_so100_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --batch_size=4 --steps=30000 --seed=1000

जब यह काम नहीं करता है

• डेटासेट अस्वीकृत: v3 आवश्यक
• प्रशिक्षण के दौरान मेमोरी से बाहर
• हानि कम होती है लेकिन नीति कुछ नहीं करती
• नीति गति के बीच में रुक जाती है
• नीति केवल एक सेटअप में काम करती है
• प्रशिक्षण कार्य कतार में अटका हुआ

एक रन की लागत क्या है

Pi0.5 महंगी श्रेणी में आता है क्योंकि इसे 80 GB कार्ड की आवश्यकता होती है, और स्पॉट कीमतें बदलती रहती हैं, इसलिए यह आंकड़ा एक मूल्य के बजाय एक सीमा है। कई SO-100 कार्यों के लिए, पहले SmolVLA या ACT को पहले 24 GB श्रेणी पर प्रशिक्षित करें, पुष्टि करें कि कार्य सीखने योग्य है या नहीं, फिर उस पर A100 घंटे खर्च करें। अपनी पहली नीति को प्रशिक्षित करें उस सस्ते लूप का अनुसरण करता है, और मूल्य निर्धारण वर्तमान श्रेणियों को दर्शाता है।

एक शाम समर्पित करने से पहले: GR00T N1.7 बनाम Pi0.5 और Pi0.5 बनाम SmolVLA वही संख्याएँ आमने-सामने रखती हैं। अखाड़ा में 332 बेंचमार्क परिणामों के साथ 85 VLA मॉडल हैं, प्रत्येक अपने स्रोत से जुड़ा हुआ है, और परिवार की पृष्ठभूमि हमारे VLA अवलोकन में है।