Hur man tränar Pi0.5 med dina egna robotdata

Pi0.5 är modellen du väljer när en policy måste fungera i ett rum den aldrig har sett. Det är också den mest besvärliga av de fem träningsbara policyer här för att finjustera för hand: det uppströmslagret är JAX-först, LeRobot-porten flyttade ut distributionen från lerobot-record i 0.6.0 och gjorde basinstallationen för liten för att träna med, och en fullständig finjustering får inte plats på en 4090. Nedan: vad flödesmatchning kostar vid inferens, de två kommandovägarna och siffran 485 ms som avgör om resultatet är användbart.

Vad Pi0.5 egentligen är

Physical Intelligence publicerade pi0 i oktober 2024: en flödesmatchande syn-språk-handlingsmodell på en förtränad VLM: PaliGemma med 3 miljarder parametrar plus en 300M åtgärdsexpert initialiserad från grunden, totalt 3.3 miljarder. Rapporten redovisar förträning på över 10 000 timmar robotdata över 7 robotkonfigurationer och 68 uppgifter. Mer i pi0-artikeln.

Pi0.5 (arXiv 2504.16054, 22 April 2025) behåller det skelettet och ändrar träningsdieten: webbdata, objektdetektering, verbala instruktioner från människor som coachar roboten, deluppgiftsetiketter, data från olika robotkroppar i många hem. Resultatet är en robot som städar kök i hus som inte ingick i träningsuppsättningen. openpi README lägger till en detalj som titeln inte gör: den släppta pi0.5 tränades med kunskapsisolering (arXiv 2505.23705).

Vad flow matching ändrar gällande träning och inferens

En policy som du kan träna på en SO-100 antingen regresserar handlingar direkt (ACT) eller tokeniserar dem och avkodar autoregressivt (pi0-FAST). Flödesmatchning gör ingetdera: den lär sig ett vektorfält som transporterar brus till en ren handlingsbit, och integrerar den sedan. Pi0-artikeln använder 10 integrationssteg med stegstorlek 0.1; LeRobots pi05-konfiguration har samma num_inference_steps: int = 10.

• Träning: förlusten regresserar en brusig handlingsbit. Ingen tokeniserare att finjustera, ingen diskretisering av dina ledvinklar.
• Inferens: en bit kostar tio framåtkörningar genom handlingsexperten. Det är strukturellt, inte ett finjusteringsproblem.
• Utdata: kontinuerliga handlingar av dimension 32, internt utfyllda, förlust beräknad på de dimensioner din robot har. En 6-DoF arm plus gripdon använder 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, och grinden framför den

PaliGemma (arXiv 2407.07726) är en SigLIP-So400m visionskodare på en Gemma-2B språkmodell, med cirka 3 miljarder parametrar. Pi0.5 ärver dess tokenizer, och den tokenizern finns i ett begränsat (gated) arkiv. Detta är det vanligaste sättet en första körning misslyckas, innan det första träningssteget.

Innan du börjar: datasetformat, episoder, hårdvara

Pi0.5 i LeRobot läser ett LeRobot-dataset i v3.0-layout, som lanserades med lerobot 0.4.0 i oktober 2025: många episoder per Parquet- och MP4-fil istället för en fil per episod, med gränser i meta/episodes/ istället för filnamn. Spela in med skrivbordsklienten eller följ spela in ditt första dataset och 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 kräver minst 50 avsnitt för Pi0.5, samma miniminivå som för GR00T och ACT. Förträning gör det tunga arbetet, så 50 rena avsnitt är bättre än 200 slarviga. Ny på detta? Börja med datainsamlingsguiden.

Rutt A: finjustera med openpi-förrådet

Referensimplementeringen: JAX först, endast testad på Ubuntu 22.04, driven av konfigurationsobjekt snarare än flaggor. En PyTorch-väg anlände i september 2025, validerad på LIBERO. Tre steg: konvertera din data, definiera en konfiguration, träna och driftsätt.

1. 1
   Klona och installera

   openpi använder uv. GIT_LFS_SKIP_SMUDGE är det som låter LeRobot inkluderas som ett beroende utan LFS-blobbar.

   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
   Konvertera din data till ett LeRobot-dataset

   Upstream levererar konverterare för LIBERO och DROID och förväntar sig att du anpassar en. Arbetet är nyckelmappningen.

   bash

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

3. 3
   Lägg till en träningskonfiguration

   Konfigurationer är TrainConfig-poster i src/openpi/training/config.py. Denna anpassar pi05_droid_finetune, med viktladdaren pekande 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
   Beräkna normaliseringsstatistik

   Körs mot konfigurationsnamnet, inte datasetet. Att hoppa över det är det klassiska första felet här.

   bash

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

5. 5
   Träna

   Variabeln låter JAX använda 90 procent av GPU-minnet istället för standardvärdet 75. På ett 80 GB-kort avgör det om körningen överlever.

   bash

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

6. 6
   Driftsätt den

   Servern lyssnar på port 8000 och svarar på observationsfrågor; din robotkörtid är klienten.

   bash

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

Rutt B: finjustera med lerobot pi05

LeRobot-porten omsluter samma vikter i CLI som du redan använder för ACT och SmolVLA. Allt nedan kontrollerades mot lerobot 0.6.1, releasen sedan 3 augusti 2026, och pi05-dokumentationen den 23 augusti 2026. Versioner spelar roll här: v3.0-dataset anlände med 0.4.0 i oktober 2025, 0.5.0-bloggen den 9 mars 2026 presenterar pi0-FAST och Real-Time Chunking, och 0.6.0 den 6 juli 2026 gjorde baspaketet lättviktigt och flyttade distributionen till lerobot-rollout.

En sak flyttades inte: lerobot-train och lerobot-record var redan startpunkter i 0.3.2, augusti 2025. En handledning som fortfarande anropar python -m lerobot.scripts.train föregår ett års förändringar och är värd att misstro även i övrigt.

1. 1
   Installera med rätt tillägg

   Sedan 0.6.0 innehåller basinstallationen endast kärnberoenden för maskininlärning, och pi-tillägget lägger inte till någon dataset- eller träningskod, så en finjustering kräver även tränings-tillägget. Äldre enradskommandon misslyckas här vid import.

   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
   Autentisera

   Acceptera paligemma-3b-pt-224-licensen i en webbläsare, logga sedan in på maskinen som tränar.

   bash

   hf auth login

3. 3
   Lägg till kvantilstatistik

   Pi0.5 normaliserar STATE och ACTION med kvantiler, så meta/stats.json behöver q01 och q99. Äldre dataset innehåller endast min, max, medelvärde, std.

   bash

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

4. 4
   Finjustera från lerobot/pi05_base

   Ställ in batchstorleken till vad ditt grafikkort klarar; dokumentationen använder 64 på LIBERO med 80 GB. Skicka bfloat16 explicit, standardinställningen i konfigurationen är 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 den på armen

   I 0.6.x är detta lerobot-rollout: lerobot-record vägrar en policy och avvisar eval_-datasetnamn. Base driver armen, sentry spelar in rollouten.

   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 uppsättningar standardvärden, och vilka som når tränaren

openpi:s TrainConfig är referensen, LeRobots PI05Config är vad lerobot-train använder när du inte anger något, och formuläret här skickar en tredje uppsättning. Överraskningen är inlärningshastigheten: båda standardinställningarna uppströms toppar på 2.5e-5, medan openpi:s egen pi05_libero-konfiguration och denna plattform höjer den till 5e-5.

Är portningen trogen? LeRobot-teamet finjusterade LIBERO-basmodellen i ytterligare 6k steg och jämförde med openpi:s referensvärden på fyra sviter: 97.5 procent i genomsnitt mot 96.85, före på Libero 10, efter på Spatial. Vägen är ett verktygsval, inte ett kvalitetsval.

Verkligheten med 485 ms, och var det slutar vara användbart

Detta avgör ditt projekt, så det kommer före kostnadstabellen. per åtgärdssteg mätt här för Pi0.5 är 485 ms. Jämfört med de andra fyra:

Uppströms har ett svar, och hälften av det finns redan i den version du kan installera. Real-Time Chunking genererar nästa segment medan armen fortfarande utför det nuvarande, och vägleder sedan de överlappande stegen i det nya segmentet att hålla sig nära den del som redan utförts, så att armen inte stannar eller rycker vid skarven. Inferens-tidsformen levererades i 0.4.2-ändringsloggen för Pi0, Pi0.5 och SmolVLA och är en utrullningsflagga, inte en omträ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 inte modellen snabbare. Det döljer gapet: de 485 ms spenderas fortfarande, men utanför den kritiska sökvägen, så kön torkar inte ut mellan segmenten. Tränings-tidsvarianten från arXiv 2512.05964 går längre: modellen lär sig att villkora på ett rent åtgärdsprefix, så vid inferens är överlappningen hårt in-målad med flödestidssteg per åtgärd istället för guidad, och den bakåtgående vägledningspassagen försvinner. Under träning samplar den en prefixlängd per exempel och tar flödesförlusten på det återstående postfixet. Den flaggan finns endast på main, inte i 0.6.1, och fördröjningen du tränar för måste hålla sig under chunk_size.

Två sätt att få en 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

När det inte fungerar

• Dataset avvisat: v3 krävs
• Slut på minne under träning
• Förlusten minskar men policyn gör ingenting
• Policyn fryser mitt i rörelsen
• Policyn fungerar bara i en konfiguration
• Träningsjobb fastnat i kö

Vad en körning kostar

Pi0.5 ligger i den dyra nivån eftersom det kräver ett 80 GB-kort, och spotpriserna rör sig, så siffran är ett intervall snarare än ett pris. För många SO-100-uppgifter, träna SmolVLA eller ACT på 24 GB-nivån först, bekräfta att uppgiften överhuvudtaget är inlärningsbar, spendera sedan A100-timmar på den. Träna din första policy går igenom den billigare loopen, och prissättning innehåller de aktuella nivåerna.

Innan du ägnar en kväll åt det: GR00T N1.7 mot Pi0.5 och Pi0.5 mot SmolVLA presenterar samma siffror sida vid sida. Arenan innehåller 85 VLA-modeller med 332 benchmarkresultat, var och en länkad till sin källa, och bakgrund om familjen finns i vår VLA-översikt.