Hvordan trene Pi0.5 på dine egne robotdata

Pi0.5 er modellen du velger når en policy må fungere i et rom den aldri har sett. Det er også den mest tungvinte av de fem trenbare policyer her for å finjustere manuelt: det oppstrøms depotet er JAX-først, LeRobot-porten flyttet distribusjon ut av lerobot-record i 0.6.0 og gjorde basisinstallasjonen for liten til å trene med, og en full finjustering passer ikke på et 4090. Nedenfor: hva flytmatching koster ved inferens, de to kommandorutene, og tallet 485 ms som avgjør om resultatet er brukbart.

Hva Pi0.5 faktisk er

Physical Intelligence publiserte pi0 i oktober 2024: en flytmatchings visjon-språk-handling-modell på en forhåndstrent VLM: PaliGemma med 3 milliarder parametere pluss en 300M handlings-ekspert initialisert fra bunnen av, totalt 3.3 milliarder. Artikkelen rapporterer forhåndstrening på over 10 000 timer med robotdata fordelt på 7 robotkonfigurasjoner og 68 oppgaver. Mer i pi0-artikkelen.

Pi0.5 (arXiv 2504.16054, 22 April 2025) beholder det skjelettet og endrer treningsdietten: webdata, objektdeteksjon, verbale instruksjoner fra mennesker som veileder roboten, deloppgaveetiketter, tverr-kroppsdata fra roboter i mange hjem. Resultatet er en robot som rengjør kjøkken i hus som ikke var i treningssettet. openpi README legger til en detalj som tittelen ikke gjør: den utgitte pi0.5 ble trent med kunnskapsisolasjon (arXiv 2505.23705).

Hva flow matching endrer ved trening og inferens

En policy du kan trene på en SO-100 enten regredierer handlinger direkte (ACT) eller tokeniserer dem og dekoder autoregressivt (pi0-FAST). Flow matching gjør ingen av delene: den lærer et vektorfelt som transporterer støy til en ren handlingsbit, og integrerer den deretter. Pi0-artikkelen bruker 10 integrasjonstrinn med trinnstørrelse 0.1; LeRobots pi05-konfigurasjon har den samme num_inference_steps: int = 10.

• Trening: tapet regredierer en støybelagt handlingsbit. Ingen tokeniserer å justere, ingen diskretisering av leddvinklene dine.
• Inferens: én bit koster ti fremoverpasseringer gjennom handlingseksperten. Dette er strukturelt, ikke et justeringsproblem.
• Utdata: kontinuerlige handlinger av dimensjon 32, internt polstret, tap tatt på dimensjonene roboten din har. En 6-DoF arm pluss griper bruker 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-ryggraden, og porten foran den

PaliGemma (arXiv 2407.07726) er en SigLIP-So400m visjonsenkoder på en Gemma-2B språkmodell, med omtrent 3B parametere. Pi0.5 arver sin tokeniserer, og denne tokenisereren ligger i et lukket (gated) repository. Dette er den vanligste måten et første forsøk feiler på, før det første treningssteget.

Før du starter: datasettformat, episoder, maskinvare

Pi0.5 i LeRobot leser et LeRobot-datasett i v3.0-layout, som kom med lerobot 0.4.0 i oktober 2025: mange episoder per Parquet- og MP4-fil i stedet for én fil per episode, med grenser i meta/episodes/ i stedet for filnavn. Ta opp med skrivebordsklienten eller følg ta opp ditt første datasett og du har det.

# 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

Plattformen krever minst 50 episoder for Pi0.5, samme minimum som for GR00T og ACT. Forhåndstrening gjør det meste av jobben, så 50 rene episoder er bedre enn 200 slurvete. Ny på dette? Start med datainnsamlingsguiden.

Rute A: finjuster med openpi-repositoriet

Referanseimplementeringen: JAX først, kun testet på Ubuntu 22.04, drevet av konfigurasjonsobjekter i stedet for flagg. En PyTorch-sti ankom i september 2025, validert på LIBERO. Tre trinn: konverter dataene dine, definer en konfigurasjon, tren og tjen.

1. 1
   Klon og installer

   openpi bruker uv. GIT_LFS_SKIP_SMUDGE er det som lar LeRobot komme inn som en avhengighet uten 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
   Konverter dataene dine til et LeRobot-datasett

   Oppstrøms leveres konvertere for LIBERO og DROID, og du forventes å tilpasse en. Arbeidet er nøkkelkartleggingen.

   bash

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

3. 3
   Legg til en treningskonfigurasjon

   Konfigurasjoner er TrainConfig-oppføringer i src/openpi/training/config.py. Denne tilpasser pi05_droid_finetune, med vektlasteren pekt mot 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
   Beregn normaliseringsstatistikker

   Kjører mot konfigurasjonsnavnet, ikke datasettet. Å hoppe over dette er den klassiske første feilen her.

   bash

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

5. 5
   Tren

   Variabelen lar JAX bruke 90 prosent av GPU-minnet i stedet for standard 75. På et 80 GB kort avgjør det om kjøringen overlever.

   bash

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

6. 6
   Tjen den

   Serveren lytter på port 8000 og svarer på observasjonsforespørsler; robotens kjøretid er klienten.

   bash

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

Rute B: finjuster med lerobot pi05

LeRobot-porten pakker de samme vektene i CLI-en du allerede bruker for ACT og SmolVLA. Alt nedenfor ble sjekket mot lerobot 0.6.1, utgivelsen siden 3. august 2026, og pi05-dokumentasjonen den 23. august 2026. Versjoner er viktige her: v3.0 datasett ankom med 0.4.0 i oktober 2025, 0.5.0-bloggen fra 9. mars 2026 presenterer pi0-FAST og Real-Time Chunking, og 0.6.0 den 6. juli 2026 gjorde basispakken lettvektig og flyttet distribusjon til lerobot-rollout.

Én ting flyttet ikke på seg: lerobot-train og lerobot-record var allerede inngangspunkter i 0.3.2, august 2025. En veiledning som fortsatt kaller python -m lerobot.scripts.train er eldre enn et år med endringer og er verdt å mistro på resten også.

1. 1
   Installer med de riktige tilleggene

   Siden 0.6.0 inneholder basisinstallasjonen kun kjerne-ML-avhengigheter, og pi-ekstraen legger ikke til datasett- eller treningskode, så en finjustering krever også trenings-ekstraen. Eldre enlinjere feiler her ved importtid.

   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
   Autentiser

   Godta paligemma-3b-pt-224-lisensen i en nettleser, logg deretter inn på maskinen som trener.

   bash

   hf auth login

3. 3
   Legg til kvantilstatistikk

   Pi0.5 normaliserer STATE og ACTION med kvantiler, så meta/stats.json trenger q01 og q99. Eldre datasett inneholder kun min, maks, gjennomsnitt, std.

   bash

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

4. 4
   Finjuster fra lerobot/pi05_base

   Sett batchstørrelsen til det kortet ditt tåler; dokumentasjonen bruker 64 på LIBERO med 80 GB. Send bfloat16 eksplisitt, standardkonfigurasjonen er 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
   Kjør det på armen

   I 0.6.x er dette lerobot-rollout: lerobot-record nekter en policy og avviser eval_-datasettnavn. Base driver armen, sentry registrerer utrullingen.

   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

Tre sett med standardinnstillinger, og hvilke som når treneren

openpis TrainConfig er referansen, LeRobots PI05Config er det lerobot-train bruker når du ikke spesifiserer noe, og skjemaet her sender et tredje sett. Overraskelsen er læringsraten: begge oppstrøms standardinnstillinger topper på 2.5e-5, mens openpis egen pi05_libero-konfigurasjon og denne plattformen øker den til 5e-5.

Er porten trofast? LeRobot-teamet finjusterte LIBERO-basemodellen i ytterligere 6k steg og sammenlignet med openpis referansetall på fire suiter: 97.5 prosent gjennomsnitt mot 96.85, foran på Libero 10, bak på Spatial. Ruten er et verktøyvalg, ikke et kvalitetsvalg.

485 ms-virkeligheten, og hvor den slutter å være brukbar

Dette avgjør prosjektet ditt, så det kommer før kostnadstabellen. inferenslatens per handlingstrinn målt her for Pi0.5 er 485 ms. Mot de fire andre:

Oppstrøms har et svar, og halvparten av det er allerede i utgivelsen du kan installere. Sanntids-chunking genererer neste bit mens armen fortsatt utfører den nåværende, og veileder deretter de overlappende trinnene i den nye biten til å holde seg nær den delen som allerede er utført, slik at armen ikke stopper eller rykker ved skjøten. Inferens-tidsformen ble levert i 0.4.2 endringsloggen for Pi0, Pi0.5 og SmolVLA og er et utrullingsflagg, ikke en omtrening:

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

Det gjør ikke modellen raskere. Det skjuler gapet: de 485 ms brukes fortsatt, men utenfor den kritiske banen, slik at køen ikke går tom mellom bitene. Trenings-tidsvarianten fra arXiv 2512.05964 går lenger: modellen lærer å betinge seg på et rent handlingsprefiks, slik at ved inferens blir overlappingen hard-innmalt med flyt-tidstrinn per handling i stedet for veiledet, og veiledningens bakoverpass forsvinner. Under trening samples en prefikslengde per eksempel og flyttapet tas på den gjenværende postfixen. Dette flagget finnes kun på main, ikke i 0.6.1, og forsinkelsen du trener for må holde seg under chunk_size.

To måter å få et Pi0.5 sjekkpunkt

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

Når det ikke fungerer

• Datasett avvist: v3 påkrevd
• Utilstrekkelig minne under trening
• Tapet faller, men policyen gjør ingenting
• Policyen fryser midt i bevegelsen
• Policyen fungerer bare i ett oppsett
• Treningsjobb sitter fast i kø

Hva en kjøring koster

Pi0.5 er i det dyre sjiktet fordi den krever et 80 GB kort, og spotpriser varierer, så tallet er et intervall snarere enn en fast pris. For mange SO-100-oppgaver, tren SmolVLA eller ACT på 24 GB-nivået først, bekreft at oppgaven i det hele tatt er læringsbar, og bruk deretter A100-timer på den. Tren din første policy beskriver den billigere prosessen, og priser viser de nåværende nivåene.

Før du forplikter en kveld: GR00T N1.7 mot Pi0.5 og Pi0.5 mot SmolVLA legger de samme tallene frem side om side. Arenaen inneholder 85 VLA-modeller med 332 benchmark-resultater, hver lenket til sin kilde, og bakgrunn om familien finnes i vår VLA-oversikt.