Paano Sanayin ang Pi0.5 sa Sarili Mong Data ng Robot

Ang Pi0.5 ay ang modelo na ginagamit mo kapag ang isang patakaran ay kailangang gumana sa isang silid na hindi pa nito nakita. Ito rin ang pinakamahirap sa limang mga patakarang maaaring sanayin dito upang i-fine-tune nang mano-mano: ang upstream repository ay JAX muna, inilipat ng LeRobot port ang deployment palabas ng lerobot-record sa 0.6.0 at ginawang masyadong maliit ang base install para sa pagsasanay, at ang isang buong fine-tune ay hindi kasya sa isang 4090. Sa ibaba: kung ano ang flow matching na gastos sa inference, ang dalawang ruta ng command, at ang numerong 485 ms na nagpapasya kung magagamit ang resulta.

Ano talaga ang Pi0.5

Inilathala ng Physical Intelligence ang pi0 noong Oktubre 2024: isang flow matching modelo ng vision-language-action sa isang pretrained VLM: PaliGemma sa 3 bilyong parameter kasama ang isang 300M action expert na sinimulan mula sa simula, 3.3 bilyon sa kabuuan. Iniulat ng papel ang pre-training sa mahigit 10,000 oras ng data ng robot sa 7 configuration ng robot at 68 gawain. Higit pa sa artikulo ng pi0.

Pi0.5 (arXiv 2504.16054, 22 April 2025) pinanatili ang balangkas na iyon at binago ang diet sa pagsasanay: data mula sa web, object detection, verbal na instruksyon mula sa mga tao na nagtuturo sa robot, mga label ng subtask, cross-embodiment data mula sa mga robot sa maraming tahanan. Ang resulta ay isang robot na naglilinis ng mga kusina sa mga bahay na wala sa training set. Idinagdag ng openpi README ang isang detalye na hindi nabanggit sa pamagat: ang inilabas na pi0.5 ay sinanay na may knowledge insulation (arXiv 2505.23705).

Ano ang binabago ng flow matching tungkol sa pagsasanay at inference

Ang patakaran na maaari mong sanayin sa isang SO-100 ay direktang nagre-regress ng mga aksyon (ACT) o nagta-tokenize at nagde-decode ng mga ito nang autoregressively (pi0-FAST). Ang flow matching ay hindi ginagawa ang alinman sa mga ito: natututo ito ng isang vector field na naglilipat ng ingay sa isang malinis na bahagi ng aksyon, pagkatapos ay isinasama ito. Ang pi0 paper ay gumagamit ng 10 integration steps sa step size na 0.1; ang pi05 config ng LeRobot ay nagtataglay ng parehong num_inference_steps: int = 10.

• Pagsasanay: ang loss ay nagre-regress ng isang maingay na bahagi ng aksyon. Walang tokenizer na kailangang i-tune, walang discretisation ng iyong mga joint angle.
• Inference: isang bahagi ng aksyon ang nagkakahalaga ng sampung forward pass sa pamamagitan ng action expert. Ito ay structural, hindi isang problema sa pag-tune.
• Output: tuloy-tuloy na mga aksyon ng dimension 32, na may internal padding, ang loss ay kinukuha sa mga dimension na mayroon ang iyong robot. Ang isang 6-DoF na braso kasama ang gripper ay gumagamit ng 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

Ang PaliGemma backbone, at ang gate sa harap nito

Ang PaliGemma (arXiv 2407.07726) ay isang SigLIP-So400m vision encoder sa isang Gemma-2B language model, na may humigit-kumulang 3B na parameter. Minana ng Pi0.5 ang tokenizer nito, at ang tokenizer na iyon ay nasa isang gated repository. Ito ang pinakakaraniwang paraan kung paano nabibigo ang unang pagpapatakbo, bago ang unang hakbang sa pagsasanay.

Bago ka magsimula: format ng dataset, mga episode, hardware

Ang Pi0.5 sa LeRobot ay nagbabasa ng isang LeRobot dataset sa v3.0 layout, na inilabas kasama ng lerobot 0.4.0 noong Oktubre 2025: maraming episode bawat Parquet at MP4 file sa halip na isang file bawat episode, na may mga hangganan sa meta/episodes/ sa halip na mga filename. Mag-record gamit ang desktop client o sundin ang i-record ang iyong unang dataset at mayroon ka na nito.

# 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

Ang platform ay nangangailangan ng hindi bababa sa 50 episode para sa Pi0.5, kapareho ng bilang para sa GR00T at ACT. Ang pre-training ang gumagawa ng mabigat na trabaho, kaya mas mahusay ang 50 malinis na episode kaysa sa 200 na hindi maayos. Bago ka rito? Magsimula sa ang gabay sa pagkolekta ng data.

Ruta A: fine-tune gamit ang openpi repository

Ang reference implementation: JAX muna, sinubukan lamang sa Ubuntu 22.04, pinapatakbo ng mga config object sa halip na mga flag. Isang PyTorch path ang dumating noong Setyembre 2025, na-validate sa LIBERO. Tatlong hakbang: i-convert ang iyong data, tukuyin ang isang config, i-train at i-serve.

1. 1
   I-clone at i-install

   Gumagamit ang openpi ng uv. Ang GIT_LFS_SKIP_SMUDGE ang nagpapahintulot sa LeRobot na maging dependency nang walang LFS blobs.

   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
   I-convert ang iyong data sa isang LeRobot dataset

   Ang upstream ay nagpapadala ng mga converter para sa LIBERO at DROID at inaasahan kang umangkop ng isa. Ang trabaho ay ang key mapping.

   bash

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

3. 3
   Magdagdag ng training config

   Ang mga config ay TrainConfig entries sa src/openpi/training/config.py. Ang isang ito ay umaangkop sa pi05_droid_finetune, na ang weight loader ay nakaturo sa 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
   I-compute ang norm stats

   Tumatakbo laban sa pangalan ng config, hindi sa dataset. Ang paglaktaw nito ang klasikong unang pagkabigo dito.

   bash

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

5. 5
   I-train

   Pinapayagan ng variable ang JAX na gumamit ng 90 porsiyento ng memorya ng GPU sa halip na ang default na 75. Sa isang 80 GB card, ito ang nagpapasya kung magpapatuloy ang pagtakbo.

   bash

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

6. 6
   I-serve ito

   Nakikinig ang server sa port 8000 at sumasagot sa mga observation query; ang iyong robot runtime ang client.

   bash

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

Ruta B: fine-tune gamit ang lerobot pi05

Ang LeRobot port ay nagbabalot ng parehong weights sa CLI na ginagamit mo na para sa ACT at SmolVLA. Ang lahat ng nasa ibaba ay sinuri laban sa lerobot 0.6.1, ang release mula noong 3 Agosto 2026, at ang mga dokumento ng pi05 noong 23 Agosto 2026. Mahalaga ang mga bersyon dito: dumating ang v3.0 datasets kasama ang 0.4.0 noong Oktubre 2025, ang 0.5.0 blog ng 9 Marso 2026 ay nagpapakita ng pi0-FAST at Real-Time Chunking, at ginawa ng 0.6.0 noong 6 Hulyo 2026 na maging lightweight ang base package at inilipat ang deployment sa lerobot-rollout.

Isang bagay ang hindi nagbago: ang lerobot-train at lerobot-record ay mga entry point na noong 0.3.2, Agosto 2025. Ang isang tutorial na tumatawag pa rin sa python -m lerobot.scripts.train ay mas matanda pa sa isang taon ng mga pagbabago at hindi dapat pagkatiwalaan sa iba pa.

1. 1
   I-install gamit ang tamang extras

   Mula 0.6.0, ang base install ay naglalaman lamang ng core ML dependencies, at ang pi extra ay hindi nagdaragdag ng dataset o training code, kaya ang isang fine-tune ay nangangailangan din ng training extra. Ang mga mas lumang one-liners ay nabibigo dito sa import time.

   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
   Mag-authenticate

   Tanggapin ang lisensya ng paligemma-3b-pt-224 sa isang browser, pagkatapos ay mag-log in sa makina na nagsasanay.

   bash

   hf auth login

3. 3
   Magdagdag ng quantile statistics

   Ang Pi0.5 ay nagno-normalize ng STATE at ACTION gamit ang quantiles, kaya ang meta/stats.json ay nangangailangan ng q01 at q99. Ang mga mas lumang dataset ay naglalaman lamang ng 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
   I-fine-tune mula sa lerobot/pi05_base

   Itakda ang batch size sa kung ano ang kayang suportahan ng iyong card; ang mga docs ay gumagamit ng 64 sa LIBERO sa 80 GB. Ipasa ang bfloat16 nang eksplisito, ang default ng config ay 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
   Patakbuhin ito sa braso

   Sa 0.6.x ito ay lerobot-rollout: ang lerobot-record ay tumatanggi sa isang policy at tinatanggihan ang mga pangalan ng eval_ dataset. Ang Base ay nagmamaneho ng braso, ang sentry ay nagre-record ng rollout.

   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

Tatlong set ng defaults, at alin ang nakakarating sa trainer

Ang TrainConfig ng openpi ang reperensiya, ang PI05Config ng LeRobot ang ginagamit ng lerobot-train kapag wala kang sinabi, at ang form dito ay nagpapadala ng ikatlong set. Ang nakakagulat ay ang learning rate: parehong umaabot sa 2.5e-5 ang mga default ng upstream, habang ang sariling pi05_libero config ng openpi at ang platform na ito ay nagpapataas nito sa 5e-5.

Tapat ba ang port? Ang LeRobot team ay nag-fine-tune ng LIBERO base model para sa karagdagang 6k na hakbang at inihambing ito sa mga reference number ng openpi sa apat na suite: 97.5 porsiyentong average laban sa 96.85, nangunguna sa Libero 10, nahuhuli sa Spatial. Ang ruta ay isang pagpipilian sa tooling, hindi sa kalidad.

Ang katotohanan ng 485 ms, at kung saan ito humihinto sa pagiging kapaki-pakinabang

Ito ang nagpapasya sa iyong proyekto, kaya ito ay nauuna sa talahanayan ng gastos. Ang bawat hakbang ng aksyon na sinukat dito para sa Pi0.5 ay 485 ms. Laban sa iba pang apat:

May sagot ang upstream, at kalahati nito ay nasa release na na maaari mong i-install. Ang Real-Time Chunking ay bumubuo ng susunod na chunk habang isinasagawa pa rin ng braso ang kasalukuyan, pagkatapos ay ginagabayan ang mga magkakapatong na hakbang ng bagong chunk upang manatiling malapit sa bahaging naisagawa na, upang hindi huminto o umalog ang braso sa pinagdugtungan. Ang inference-time form na kasama sa 0.4.2 changelog para sa Pi0, Pi0.5 at SmolVLA ay isang rollout flag, hindi isang retrain:

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

Hindi nito pinapabilis ang modelo. Itinatago nito ang agwat: ang 485 ms ay ginugugol pa rin, ngunit wala sa kritikal na landas, kaya hindi nauubusan ang queue sa pagitan ng mga chunk. Ang variant ng training-time mula sa arXiv 2512.05964 ay mas malalim: natututo ang modelo na mag-condition sa isang malinis na action prefix, kaya sa inference ang overlap ay hard-inpainted na may per-action flow timesteps sa halip na guided, at nawawala ang guidance backward pass. Sa panahon ng training, kumukuha ito ng prefix length bawat halimbawa at kinukuha ang flow loss sa natitirang postfix. Ang flag na iyon ay nasa main lamang, hindi sa 0.6.1, at ang delay na iyong sinasanay ay kailangang manatili sa ibaba ng chunk_size.

Dalawang paraan para makakuha ng Pi0.5 checkpoint

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

Kapag hindi ito gumagana

• Dataset tinanggihan: kailangan ang v3
• Out of memory habang nagsasanay
• Bumaba ang loss ngunit walang ginagawa ang policy
• Nag-freeze ang policy sa kalagitnaan ng paggalaw
• Gumagana lang ang policy sa isang setup
• Naipit ang training job sa queued

Magkano ang gastos ng isang run

Ang Pi0.5 ay nasa mamahaling tier dahil nangangailangan ito ng 80 GB card, at nagbabago ang mga spot price, kaya ang figure ay isang range sa halip na isang presyo. Para sa maraming SO-100 na gawain, sanayin SmolVLA o ACT sa 24 GB tier muna, kumpirmahin na matututunan ang gawain, pagkatapos ay gumugol ng A100 oras dito. Sanayin ang iyong unang policy ay nagpapakita ng mas murang proseso, at pagpepresyo ay naglalaman ng kasalukuyang mga tier.

Bago maglaan ng isang gabi: GR00T N1.7 laban sa Pi0.5 at Pi0.5 laban sa SmolVLA ay nagpapakita ng parehong mga numero nang direkta. Ang Arena ay naglalaman ng 85 modelo ng VLA na may 332 resulta ng benchmark, bawat isa ay naka-link sa pinagmulan nito, at ang background tungkol sa pamilya ay nasa aming pangkalahatang-ideya ng VLA.