Hoe om Pi0.5 op Jou Eie Robotdata op te Lei

Pi0.5 is die model waarvoor jy kies wanneer 'n beleid moet werk in 'n kamer wat dit nog nooit gesien het nie. Dit is ook die mees ongemaklike van die vyf opleibare beleide hier om fyninstel met die hand: die stroomop-bewaarplek is JAX eerste, die LeRobot-poort het ontplooiing uit lerobot-record in 0.6.0 verskuif en die basisinstallasie te klein gemaak om mee op te lei, en 'n volle fyninstelling pas nie op 'n 4090 nie. Hieronder: wat vloeipaspassing kos by inferensie, die twee opdragroetes, en die 485 ms-getal wat besluit of die resultaat bruikbaar is.

Wat Pi0.5 werklik is

Physical Intelligence het pi0 in Oktober 2024 gepubliseer: 'n vloeipaspassing visie-taal-aksie-model op 'n vooraf-opgeleide VLM: PaliGemma met 3 miljard parameters plus 'n 300M aksie-ekspert wat van nuuts af geïnisialiseer is, 3.3 miljard in totaal. Die artikel rapporteer vooropleiding op meer as 10,000 uur se robotdata oor 7 robotkonfigurasies en 68 take. Meer in die pi0-artikel.

Pi0.5 (arXiv 2504.16054, 22 April 2025) behou daardie raamwerk en verander die opleidingsdieet: webdata, objekopsporing, verbale instruksies van mense wat die robot afrig, subtaaketikette, kruis-inkarnasie data van robotte in baie huise. Die resultaat is 'n robot wat kombuise skoonmaak in huise wat nie in die opleidingsstel was nie. Die openpi README voeg 'n detail by wat die titel nie doen nie: die vrygestelde pi0.5 is opgelei met kennis-isolasie (arXiv 2505.23705).

Wat 'flow matching' verander aan opleiding en inferensie

'n beleid wat jy op 'n SO-100 kan oplei, regresseer aksies direk (ACT) of tokeniseer dit en dekodeer outoregressief (pi0-FAST). Vloeipaspassing doen nie een van die twee nie: dit leer 'n vektorveld wat geraas na 'n skoon aksiebrok, en integreer dit dan. Die pi0-artikel gebruik 10 integrasiestappe teen 'n stapgrootte van 0.1; LeRobot se pi05-konfigurasie dra dieselfde `num_inference_steps: int = 10`.

• Opleiding: die verlies regresseer 'n geraasde aksiebrok. Geen tokeniseerder om in te stel nie, geen diskretisering van jou gewrigshoeke nie.
• Inferensie: een brok kos tien vorentoe-passe deur die aksie-ekspert. Dit is struktureel, nie 'n instellingsprobleem nie.
• Uitvoer: kontinue aksies van dimensie 32, intern opgevul, verlies geneem op die dimensies wat jou robot het. 'n 6-DoF arm plus gryper gebruik 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

Die PaliGemma-ruggraat, en die hek daarvoor

PaliGemma (arXiv 2407.07726) is 'n SigLIP-So400m visie-enkodeerder op 'n Gemma-2B taalmodel, ongeveer 3B parameters. Pi0.5 erf sy tokeniseerder, en daardie tokeniseerder is in 'n omheinde bewaarplek. Dit is die mees algemene manier waarop 'n eerste lopie misluk, voor die eerste opleidingstap.

Voordat jy begin: datastelformaat, episodes, hardeware

Pi0.5 in LeRobot lees 'n LeRobot-datastel in v3.0-uitleg, wat met lerobot 0.4.0 in Oktober 2025 vrygestel is: baie episodes per Parquet- en MP4-lêer in plaas van een lêer per episode, met grense in meta/episodes/ eerder as lêername. Neem op met die rekenaarkliënt of volg neem jou eerste datastel op en jy het dit.

# 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

Die platform benodig ten minste 50 episodes vir Pi0.5, dieselfde minimum as GR00T en ACT. Vooropleiding doen die swaar werk, so 50 skoon episodes is beter as 200 slordige episodes. Nuut hiermee? Begin met die data-insamelingsgids.

Roete A: fyninstel met die openpi-bewaarplek

Die verwysingsimplementering: JAX eerste, slegs op Ubuntu 22.04 getoets, gedryf deur konfigurasie-objekte eerder as vlae. 'n PyTorch-pad het in September 2025 aangekom, gevalideer op LIBERO. Drie stappe: skakel jou data om, definieer 'n konfigurasie, lei op en bedien.

1. 1
   Kloon en installeer

   openpi gebruik uv. GIT_LFS_SKIP_SMUDGE is wat LeRobot as 'n afhanklikheid toelaat sonder 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
   Skakel jou data om na 'n LeRobot-datastel

   Stroomop lewer omsetters vir LIBERO en DROID en verwag dat jy een sal aanpas. Die werk is die sleutelmapping.

   bash

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

3. 3
   Voeg 'n opleidingskonfigurasie by

   Konfigurasies is TrainConfig-inskrywings in src/openpi/training/config.py. Hierdie een pas pi05_droid_finetune aan, met die gewiglaaier wat na pi05_base wys.

   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
   Bereken normstatistieke

   Loop teen die konfigurasienaam, nie die datastel nie. Om dit oor te slaan is die klassieke eerste mislukking hier.

   bash

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

5. 5
   Lei op

   Die veranderlike laat JAX 90 persent van GPU-geheue gebruik in plaas van die verstek 75. Op 'n 80 GB-kaart besluit dit of die uitvoering oorleef.

   bash

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

6. 6
   Bedien dit

   Die bediener luister op poort 8000 en beantwoord waarnemingsnavrae; jou robot-looptyd is die kliënt.

   bash

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

Roete B: fyninstel met lerobot pi05

Die LeRobot-poort omsluit dieselfde gewigte in die CLI wat jy reeds gebruik vir ACT en SmolVLA. Alles hieronder is nagegaan teen lerobot 0.6.1, die vrystelling sedert 3 Augustus 2026, en die pi05-dokumente op 23 Augustus 2026. Weergawes is hier belangrik: v3.0 datastelle het met 0.4.0 in Oktober 2025 aangekom, die 0.5.0 blog van 9 Maart 2026 stel pi0-FAST en Real-Time Chunking bekend, en 0.6.0 op 6 Julie 2026 het die basispakket liggewig gemaak en ontplooiing na lerobot-rollout verskuif.

Een ding het nie verskuif nie: lerobot-train en lerobot-record was reeds toegangspunte in 0.3.2, Augustus 2025. 'n Tutoriaal wat steeds python -m lerobot.scripts.train aanroep, dateer 'n jaar van veranderinge voor en is ook die res daarvan onbetroubaar.

1. 1
   Installeer met die regte ekstras

   Sedert 0.6.0 dra die basisinstallasie slegs kern ML-afhanklikhede, en die pi-ekstra voeg geen datastel- of opleidingskode by nie, so 'n fyninstelling benodig ook die opleidingsekstra. Ouer eenlyners misluk hier by invoertyd.

   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
   Verifieer

   Aanvaar die paligemma-3b-pt-224 lisensie in 'n blaaier, meld dan aan op die masjien wat oplei.

   bash

   hf auth login

3. 3
   Voeg kwantielstatistieke by

   Pi0.5 normaliseer STATE en ACTION met kwantiele, so meta/stats.json benodig q01 en q99. Ouer datastelle bevat slegs min, maks, gemiddeld, std.

   bash

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

4. 4
   Fyninstelling vanaf lerobot/pi05_base

   Stel bondelgrootte in op wat jou kaart kan hanteer; die dokumente gebruik 64 op LIBERO teen 80 GB. Gee bfloat16 eksplisiet deur, die konfigurasie se verstek is 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
   Loop dit op die arm

   In 0.6.x is dit lerobot-rollout: lerobot-record weier 'n beleid en verwerp eval_ datastelname. Basis dryf die arm, sentry teken die uitrol aan.

   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

Drie stelle verstekwaardes, en watter die opleier bereik

openpi se TrainConfig is die verwysing, LeRobot se PI05Config is wat lerobot-train gebruik as jy niks sê nie, en die vorm hier stuur 'n derde stel. Die verrassing is die leertempo: beide stroomop verstekwaardes bereik 'n hoogtepunt van 2.5e-5, terwyl openpi se eie pi05_libero konfigurasie en hierdie platform dit verhoog na 5e-5.

Is die poort getrou? Die LeRobot-span het die LIBERO-basismodel vir 'n verdere 6k stappe verfyn en vergelyk met openpi se verwysingsgetalle op vier suites: 97.5 persent gemiddeld teenoor 96.85, voor op Libero 10, agter op Spatial. Die roete is 'n gereedskapkeuse, nie 'n kwaliteitkeuse nie.

Die 485 ms realiteit, en waar dit ophou bruikbaar wees

Dit besluit jou projek, so dit kom voor die kostetabel. Die per aksiestap wat hier vir Pi0.5 gemeet is, is 485 ms. Teenoor die ander vier:

Stroomop het 'n antwoord, en die helfte daarvan is reeds in die vrystelling wat jy kan installeer. Intydse Brokking genereer die volgende brok terwyl die arm nog die huidige een uitvoer, en lei dan die oorvleuelende stappe van die nuwe brok om naby die reeds uitgevoerde deel te bly, sodat die arm nie stilstaan of ruk by die naat nie. Die afleidingstyd-vorm is in die 0.4.2 veranderingslogboek vir Pi0, Pi0.5 en SmolVLA verskeep en is 'n uitrolvlag, nie 'n heropleiding nie:

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

Dit maak die model nie vinniger nie. Dit verberg die gaping: die 485 ms word steeds spandeer, maar buite die kritieke pad, sodat die tou nie tussen brokke opdroog nie. Die opleidingstyd-variant van arXiv 2512.05964 gaan verder: die model leer om te kondisioneer op 'n skoon aksievoorvoegsel, so by afleiding word die oorvleueling hard-ingeverf met per-aksie vloeitydstappe in plaas van gelei, en die leiding se terugwaartse pas verdwyn. Tydens opleiding monster dit 'n voorvoegsellengte per voorbeeld en neem die vloeiverlies op die oorblywende agtervoegsel. Daardie vlag is slegs op hoof, nie in 0.6.1 nie, en die vertraging waarvoor jy oplei, moet onder chunk_size bly.

Twee maniere om 'n Pi0.5-kontrolepunt te kry

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

Wanneer dit nie werk nie

• Datastel verwerp: v3 benodig
• Onvoldoende geheue tydens opleiding
• Verlies daal, maar die beleid doen niks
• Beleid vries in die middel van beweging
• Beleid werk slegs in een opstelling
• Opleidingswerk sit vas in tou

Wat een lopie kos

Pi0.5 is in die duur vlak omdat dit 'n 80 GB kaart benodig, en spotpryse beweeg, so die syfer is 'n reeks eerder as 'n prys. Vir baie SO-100 take, oefen SmolVLA of ACT op die 24 GB vlak eers, bevestig dat die taak hoegenaamd aanleerbaar is, spandeer dan A100 ure daaraan. Oefen jou eerste beleid loop daardie goedkoper lus, en pryse dra die huidige vlakke.

Voordat jy 'n aand daaraan wy: en lê dieselfde syfers kop aan kop uit. Die bevat 85 VLA-modelle met 332 maatstafresultate, elk gekoppel aan sy bron, en agtergrond oor die familie is in .