Sådan træner du Pi0.5 med dine egne robotdata

Pi0.5 er den model, du griber til, når en politik skal fungere i et rum, den aldrig har set. Det er også den mest besværlige af de fem trænbare politikker her til at finjustere manuelt: det upstream-repository er JAX først, LeRobot-porten flyttede deployment ud af lerobot-record i 0.6.0 og gjorde basisinstallationen for lille til at træne med, og en fuld finjustering passer ikke på en 4090. Nedenfor: hvad flow matching koster ved inferens, de to kommandoruter og tallet 485 ms, der afgør, om resultatet er brugbart.

Hvad Pi0.5 egentlig er

Physical Intelligence udgav pi0 i oktober 2024: en flow-matching vision-sprog-handlingsmodel på en fortrænet VLM: PaliGemma med 3 milliarder parametre plus en 300M action-ekspert initialiseret fra bunden, 3.3 milliarder i alt. Artiklen rapporterer fortræning på over 10.000 timers robotdata på tværs af 7 robotkonfigurationer og 68 opgaver. Mere i pi0-artiklen.

Pi0.5 (arXiv 2504.16054, 22. april 2025) bevarer det skelet og ændrer træningskosten: webdata, objektdetektion, verbale instruktioner fra mennesker, der coacher robotten, undertaskelabels, tværgående data fra robotter i mange hjem. Resultatet er en robot, der rengør køkkener i huse, som ikke var en del af træningssættet. openpi README tilføjer en detalje, som titlen ikke gør: den udgivne pi0.5 blev trænet med knowledge insulation (arXiv 2505.23705).

Hvad flow matching ændrer ved træning og inferens

En politik du kan træne på en SO-100, enten regredierer handlinger direkte (ACT) eller tokeniserer dem og afkoder autoregressivt (pi0-FAST). Flow matching gør ingen af delene: den lærer et vektorfelt, der transporterer støj til en ren handlingsklump, og integrerer den derefter. pi0-artiklen bruger 10 integrationstrin med trinlængde 0.1; LeRobots pi05-konfiguration indeholder den samme num_inference_steps: int = 10.

• Træning: tabet regredierer en støjfyldt handlingsklump. Ingen tokenizer at finjustere, ingen diskretisering af dine ledvinkler.
• Inference: én klump koster ti forward passes gennem handlingseksperten. Det er strukturelt, ikke et finjusteringsproblem.
• Output: kontinuerlige handlinger af dimension 32, internt polstret, tab beregnet på de dimensioner din robot har. En 6-DoF arm plus griber bruger 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-rygraden og porten foran den

PaliGemma (arXiv 2407.07726) er en SigLIP-So400m vision-encoder på en Gemma-2B sprogmodel, omkring 3B parametre. Pi0.5 arver dens tokenizer, og den tokenizer ligger i et lukket repository. Dette er den mest almindelige måde, et første kørsel dør på, før det første træningstrin.

Før du starter: datasætformat, episoder, hardware

Pi0.5 i LeRobot læser et LeRobot datasæt i v3.0-layout, som landede med lerobot 0.4.0 i oktober 2025: mange episoder pr. Parquet- og MP4-fil i stedet for én fil pr. episode, med grænser i meta/episodes/ i stedet for filnavne. Optag med desktopklient eller følg optag dit første datasæt 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

Platformen kræver mindst 50 episoder til Pi0.5, samme minimum som GR00T og ACT. Forhåndstræning udfører det tunge arbejde, så 50 rene episoder er bedre end 200 sjuskede. Ny inden for dette? Start med vejledningen til dataindsamling.

Rute A: finjuster med openpi-repository'et

Referenceimplementeringen: JAX først, kun testet på Ubuntu 22.04, drevet af konfigurationsobjekter snarere end flag. En PyTorch-sti ankom i september 2025, valideret på LIBERO. Tre trin: konverter dine data, definer en konfiguration, træn og servér.

1. 1
   Klon og installer

   openpi bruger uv. GIT_LFS_SKIP_SMUDGE er det, der lader LeRobot komme ind som en afhængighed uden 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 dine data til et LeRobot-datasæt

   Upstream leverer konvertere til LIBERO og DROID og forventer, at du tilpasser en. Arbejdet er nøglemappingen.

   bash

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

3. 3
   Tilføj en træningskonfiguration

   Konfigurationer er TrainConfig-poster i src/openpi/training/config.py. Denne tilpasser pi05_droid_finetune, med vægtloaderen pegende på 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 normstatistikker

   Kører mod konfigurationsnavnet, ikke datasættet. At springe det over er den klassiske første fejl her.

   bash

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

5. 5
   Træn

   Variablen lader JAX bruge 90 procent af GPU-hukommelsen i stedet for standard 75. På et 80 GB kort afgør det, om kørslen overlever.

   bash

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

6. 6
   Servér den

   Serveren lytter på port 8000 og besvarer observationsforespørgsler; din robot-runtime 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 indkapsler de samme vægte i den CLI, du allerede bruger til ACT og SmolVLA. Alt nedenfor blev kontrolleret mod lerobot 0.6.1, udgivelsen siden 3. august 2026, og pi05-dokumentationen den 23. august 2026. Versioner er vigtige her: v3.0 datasæt ankom med 0.4.0 i oktober 2025, 0.5.0-bloggen fra 9. marts 2026 præsenterer pi0-FAST og Real-Time Chunking, og 0.6.0 den 6. juli 2026 gjorde basispakken letvægtig og flyttede deployment til lerobot-rollout.

Én ting flyttede sig ikke: lerobot-train og lerobot-record var allerede entry points i 0.3.2, august 2025. En tutorial, der stadig kalder python -m lerobot.scripts.train, er forældet i forhold til et års ændringer og er også værd at mistro på resten.

1. 1
   Installer med de rigtige ekstraer

   Siden 0.6.0 indeholder basisinstallationen kun kerne-ML-afhængigheder, og pi-ekstra tilføjer ingen datasæt- eller træningskode, så en finjustering kræver også trænings-ekstra. Ældre one-liners fejler her ved importtidspunktet.

   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
   Autentificer

   Accepter paligemma-3b-pt-224-licensen i en browser, og log derefter ind på maskinen, der træner.

   bash

   hf auth login

3. 3
   Tilføj kvartilstatistik

   Pi0.5 normaliserer STATE og ACTION med kvartiler, så meta/stats.json kræver q01 og q99. Ældre datasæt indeholder kun min, max, gennemsnit, 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

   Indstil batchstørrelsen til det, dit kort kan klare; dokumentationen bruger 64 på LIBERO ved 80 GB. Send bfloat16 eksplicit, standardkonfigurationen 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
   Kør det på armen

   I 0.6.x er dette lerobot-rollout: lerobot-record afviser en politik og afviser eval_ datasætnavne. Base styrer armen, sentry optager udrulningen.

   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 sæt standardindstillinger, og hvilke der når træneren

openpi's TrainConfig er referencen, LeRobot's PI05Config er hvad lerobot-train bruger, når du ikke angiver noget, og formularen her sender et tredje sæt. Overraskelsen er indlæringshastigheden: begge upstream-standarder topper ved 2.5e-5, mens openpi's egen pi05_libero konfiguration og denne platform hæver den til 5e-5.

Er porten trofast? LeRobot-teamet finjusterede LIBERO-basemodellen i yderligere 6k trin og sammenlignede med openpi's referencetal på fire suiter: 97,5 procent i gennemsnit mod 96,85, foran på Libero 10, bagud på Spatial. Ruten er et værktøjsvalg, ikke et kvalitetsvalg.

De 485 ms virkelighed, og hvor det holder op med at være brugbart

Dette afgør dit projekt, så det kommer før omkostningstabellen. Den per handlingstrin målt her for Pi0.5 er 485 ms. Mod de fire andre:

Upstream har et svar, og halvdelen af det er allerede i den udgivelse, du kan installere. Real-Time Chunking genererer det næste segment, mens armen stadig udfører det nuværende, og guider derefter de overlappende trin i det nye segment til at forblive tæt på den del, der allerede er udført, så armen ikke går i stå eller rykker ved samlingen. Den inferens-tidsform, der blev leveret i 0.4.2 changelog for Pi0, Pi0.5 og SmolVLA, er et rollout-flag, ikke en gentræning:

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 gør ikke modellen hurtigere. Det skjuler hullet: de 485 ms bruges stadig, men uden for den kritiske vej, så køen ikke løber tør mellem segmenter. Træningstidsvarianten fra arXiv 2512.05964 går videre: modellen lærer at konditionere på et rent handlingspræfiks, så ved inferens er overlapningen hårdt-indmalet med flow-tidstrin per handling i stedet for guidet, og guidance backward pass forsvinder. Under træning sampler den en præfikslængde per eksempel og tager flow-tabet på den resterende postfix. Det flag findes kun på main, ikke i 0.6.1, og den forsinkelse, du træner for, skal forblive under chunk_size.

To måder at få et Pi0.5 checkpoint på

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 virker

• Datasæt afvist: v3 påkrævet
• Ikke nok hukommelse under træning
• Tab falder, men politikken gør intet
• Politikken fryser midt i bevægelsen
• Politikken virker kun i én opsætning
• Træningsjob sidder fast i kø

Hvad en kørsel koster

Pi0.5 ligger i den dyre kategori, fordi den kræver et 80 GB kort, og spotpriserne bevæger sig, så tallet er et interval snarere end en pris. For mange SO-100 opgaver, træn SmolVLA eller ACT på 24 GB kategorien først, bekræft at opgaven overhovedet kan læres, og brug derefter A100 timer på den. Træn din første politik gennemgår den billigere løkke, og priser viser de nuværende kategorier.

Før du afsætter en aften: og præsenterer de samme tal side om side. indeholder 85 VLA-modeller med 332 benchmarkresultater, hver linket til sin kilde, og baggrund om familien findes i .