तुमच्या स्वतःच्या रोबोट डेटावर 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 April 2025) तेच मूळ स्वरूप कायम ठेवते आणि प्रशिक्षणाचा आहार बदलते: वेब डेटा, ऑब्जेक्ट डिटेक्शन, रोबोटला प्रशिक्षण देणाऱ्या मानवांकडून तोंडी सूचना, उपकार्य लेबल्स, अनेक घरांमध्ये असलेल्या रोबोट्सकडून क्रॉस-एम्बॉडमेंट डेटा. याचा परिणाम म्हणजे प्रशिक्षण संचामध्ये नसलेल्या घरांमध्ये रोबोट स्वयंपाकघरे साफ करतो. openpi README शीर्षकात नसलेला एक तपशील जोडतो: प्रसिद्ध केलेला pi0.5 ज्ञान इन्सुलेशनसह (arXiv 2505.23705) प्रशिक्षित केला गेला होता.

फ्लो मॅचिंग प्रशिक्षण आणि अनुमान (inference) बद्दल काय बदलते

SO-100 वर प्रशिक्षित करता येणारी एक पॉलिसी एकतर क्रिया थेट रिग्रेस करते (ACT) किंवा त्यांना टोकनाइझ करते आणि ऑटोरेग्रेसिव्हपणे डीकोड करते (pi0-FAST). फ्लो मॅचिंग यापैकी काहीही करत नाही: ते एक वेक्टर फील्ड शिकते जे आवाज (noise) एका स्वच्छ ॲक्शन चंकमध्ये पोहोचवते, आणि नंतर ते एकत्रित करते. pi0 पेपरमध्ये 0.1 च्या स्टेप साइजवर 10 इंटिग्रेशन स्टेप्स वापरल्या जातात; LeRobot च्या pi05 कॉन्फिगमध्ये तेच num_inference_steps: int = 10 आहे.

• प्रशिक्षण: लॉस (loss) एका नॉइज्ड ॲक्शन चंकला (noised action chunk) रिग्रेस करतो. ट्यून करण्यासाठी कोणताही टोकनाइझर नाही, तुमच्या जॉइंट अँगलचे (joint angles) डिस्क्रिटायझेशन नाही.
• इन्फरन्स: एका चंकसाठी ॲक्शन एक्सपर्टमधून (action expert) दहा फॉरवर्ड पासेस लागतात. हे संरचनात्मक आहे, ट्यूनिंगची समस्या नाही.
• आउटपुट: 32 डायमेंशनच्या सततच्या क्रिया (continuous actions), अंतर्गत पॅड केलेल्या, तुमच्या रोबोटच्या डायमेंशनवर लॉस घेतला जातो. 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 बॅकबोन, आणि त्याच्या समोरचे गेट

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 ऐवजी 90 टक्के GPU मेमरी वापरण्याची परवानगी देते. 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 आणि Real-Time Chunking सादर केले, आणि 6 जुलै 2026 रोजी 0.6.0 ने बेस पॅकेज हलके केले आणि डिप्लॉयमेंट lerobot-rollout वर हलवले.

एक गोष्ट हलली नाही: lerobot-train आणि lerobot-record हे 0.3.2, ऑगस्ट 2025 मध्ये आधीच एंट्री पॉइंट्स होते. जे ट्यूटोरियल अजूनही python -m lerobot.scripts.train ला कॉल करते ते एक वर्षाच्या बदलांपूर्वीचे आहे आणि बाकीच्या बाबतीतही त्यावर विश्वास ठेवण्यासारखे नाही.

1. 1
   योग्य एक्स्ट्रासह स्थापित करा

   0.6.0 पासून, बेस इन्स्टॉलमध्ये फक्त मुख्य ML डिपेंडन्सीज असतात आणि pi एक्स्ट्रा कोणताही डेटासेट किंवा प्रशिक्षण कोड जोडत नाही, त्यामुळे फाइन-ट्यूनसाठी प्रशिक्षण एक्स्ट्राची देखील आवश्यकता असते. जुने वन-लाइनर्स येथे इम्पोर्ट करताना अयशस्वी होतात.

   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 आहे. इतर चारच्या तुलनेत:

अपस्ट्रीममध्ये एक उत्तर आहे, आणि त्यापैकी अर्धे तुम्ही स्थापित करू शकता अशा रिलीझमध्ये आधीच आहे. रिअल-टाइम चंकिंग (Real-Time Chunking) पुढील चंक तयार करते जेव्हा हात सध्याचा चंक कार्यान्वित करत असतो, त्यानंतर नवीन चंकच्या ओव्हरलॅपिंग स्टेप्सना आधीच कार्यान्वित केलेल्या भागाच्या जवळ राहण्यासाठी मार्गदर्शन करते, ज्यामुळे हात सीमवर थांबत नाही किंवा झटका देत नाही. 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 ms अजूनही खर्च होतात, परंतु क्रिटिकल पाथच्या बाहेर, त्यामुळे चंक्समध्ये रांग कोरडी पडत नाही. arXiv 2512.05964 मधील प्रशिक्षण-वेळेचे प्रकार (training-time variant) यापुढे जाते: मॉडेल स्वच्छ ॲक्शन प्रीफिक्सवर कंडिशन करायला शिकते, त्यामुळे इन्फरन्समध्ये ओव्हरलॅप मार्गदर्शित करण्याऐवजी प्रति-ॲक्शन फ्लो टाइमस्टेप्ससह हार्ड-इनपेंट केले जाते आणि मार्गदर्शन बॅकवर्ड पास अदृश्य होते. प्रशिक्षणादरम्यान ते प्रत्येक उदाहरणासाठी प्रीफिक्स लांबीचे नमुने घेते आणि उर्वरित पोस्टफिक्सवर फ्लो लॉस घेते. तो फ्लॅग फक्त मेनवर आहे, 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 समान संख्यांची समोरासमोर तुलना करतात. अरेना मध्ये 85 VLA मॉडेल्स आहेत ज्यात 332 बेंचमार्क परिणाम आहेत, प्रत्येक त्याच्या स्त्रोताशी जोडलेला आहे, आणि या कुटुंबाची पार्श्वभूमी आमच्या VLA विहंगावलोकन.