Hoe Pi0.5 te trainen met je eigen robotdata

Pi0.5 is het model waar je naar grijpt wanneer een beleid moet werken in een ruimte die het nog nooit heeft gezien. Het is ook de meest onhandige van de vijf trainable policies hier om handmatig te fine-tunen: de upstream repository is JAX-georiënteerd, de LeRobot-poort verplaatste de implementatie uit lerobot-record in 0.6.0 en maakte de basisinstallatie te klein om mee te trainen, en een volledige fine-tune past niet op een 4090. Hieronder: wat flow matching kost bij inferentie, de twee commandoroutes, en het getal van 485 ms dat bepaalt of het resultaat bruikbaar is.

Wat Pi0.5 werkelijk is

Physical Intelligence publiceerde pi0 in oktober 2024: een flow-matching visie-taal-actie-model op een voorgetraind VLM: PaliGemma met 3 miljard parameters plus een 300M actie-expert die vanaf nul is geïnitialiseerd, 3.3 miljard in totaal. Het artikel rapporteert pre-training op meer dan 10.000 uur robotdata verdeeld over 7 robotconfiguraties en 68 taken. Meer in het pi0-artikel.

Pi0.5 (arXiv 2504.16054, 22 april 2025) behoudt dat skelet en verandert het trainingsdieet: webgegevens, objectdetectie, verbale instructies van mensen die de robot coachen, subtaaklabels, cross-embodiment gegevens van robots in veel huizen. Het resultaat is een robot die keukens schoonmaakt in huizen die niet in de trainingsset zaten. De openpi README voegt een detail toe dat de titel niet vermeldt: de uitgebrachte pi0.5 werd getraind met kennisisolatie (arXiv 2505.23705).

Wat flow matching verandert aan training en inferentie

Een beleid dat je kunt trainen op een SO-100, regresseert acties direct (ACT) of tokeniseert ze en decodeert autoregressief (pi0-FAST). Flow matching doet geen van beide: het leert een vectorveld dat ruis transporteert naar een schone actiechunk, en integreert het vervolgens. Het pi0-artikel gebruikt 10 integratiestappen met een stapgrootte van 0.1; de pi05-configuratie van LeRobot heeft dezelfde num_inference_steps: int = 10.

• Training: het verlies regresseert een ruisige actiechunk. Geen tokenizer om af te stemmen, geen discretisatie van je gewrichtshoeken.
• Inference: één chunk kost tien forward passes door de actie-expert. Dat is structureel, geen afstemmingsprobleem.
• Output: continue acties van dimensie 32, intern opgevuld, verlies berekend op de dimensies die je robot heeft. Een 6-DoF arm plus grijper gebruikt 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

De PaliGemma-backbone, en de poort ervoor

PaliGemma (arXiv 2407.07726) is een SigLIP-So400m visuele encoder op een Gemma-2B taalmodel, met ongeveer 3B parameters. Pi0.5 erft zijn tokenizer, en die tokenizer bevindt zich in een afgeschermde repository. Dit is de meest voorkomende manier waarop een eerste run mislukt, vóór de eerste trainingsstap.

Voordat u begint: datasetformaat, episodes, hardware

Pi0.5 in LeRobot leest een LeRobot dataset in v3.0-indeling, die met lerobot 0.4.0 in oktober 2025 is geïntroduceerd: veel episodes per Parquet- en MP4-bestand in plaats van één bestand per aflevering, met grenzen in meta/episodes/ in plaats van bestandsnamen. Neem op met de desktopclient of volg neem uw eerste dataset op en u heeft het.

# 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

Het platform vereist minimaal 50 afleveringen voor Pi0.5, dezelfde ondergrens als GR00T en ACT. Pre-training doet het zware werk, dus 50 schone afleveringen zijn beter dan 200 slordige. Nieuw hiermee? Begin met de handleiding voor gegevensverzameling.

Route A: fine-tunen met de openpi repository

De referentie-implementatie: eerst JAX, alleen getest op Ubuntu 22.04, aangestuurd door configuratieobjecten in plaats van vlaggen. Een PyTorch-pad arriveerde in september 2025, gevalideerd op LIBERO. Drie stappen: converteer uw gegevens, definieer een configuratie, train en serveer.

1. 1
   Klonen en installeren

   openpi gebruikt uv. GIT_LFS_SKIP_SMUDGE zorgt ervoor dat LeRobot als afhankelijkheid kan worden opgenomen zonder 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
   Converteer uw gegevens naar een LeRobot-dataset

   Upstream levert converters voor LIBERO en DROID en verwacht dat u er één aanpast. Het werk zit in de sleutelmapping.

   bash

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

3. 3
   Voeg een trainingsconfiguratie toe

   Configuraties zijn TrainConfig-vermeldingen in src/openpi/training/config.py. Deze past pi05_droid_finetune aan, waarbij de gewichtslader verwijst naar 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
   Bereken normstatistieken

   Wordt uitgevoerd tegen de configuratienaam, niet de dataset. Dit overslaan is hier de klassieke eerste fout.

   bash

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

5. 5
   Trainen

   De variabele laat JAX 90 procent van het GPU-geheugen gebruiken in plaats van de standaard 75. Op een 80 GB kaart bepaalt dat of de uitvoering overleeft.

   bash

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

6. 6
   Dien het op

   De server luistert op poort 8000 en beantwoordt observatievragen; uw robotruntime is de client.

   bash

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

Route B: fine-tunen met lerobot pi05

De LeRobot-poort omvat dezelfde gewichten in de CLI die u al gebruikt voor ACT en SmolVLA. Alles hieronder is gecontroleerd tegen lerobot 0.6.1, de release sinds 3 augustus 2026, en de pi05-documentatie van 23 augustus 2026. Versies zijn hier belangrijk: v3.0 datasets kwamen met 0.4.0 in oktober 2025, de 0.5.0 blog van 9 maart 2026 presenteert pi0-FAST en Real-Time Chunking, en 0.6.0 op 6 juli 2026 maakte het basispakket lichtgewicht en verplaatste de deployment naar lerobot-rollout.

Eén ding is niet veranderd: lerobot-train en lerobot-record waren al entry points in 0.3.2, augustus 2025. Een tutorial die nog steeds python -m lerobot.scripts.train aanroept, dateert van vóór een jaar van veranderingen en is ook voor de rest het wantrouwen waard.

1. 1
   Installeren met de juiste extra's

   Sinds 0.6.0 bevat de basisinstallatie alleen kern-ML-afhankelijkheden, en de pi-extra voegt geen dataset- of trainingscode toe, dus een fine-tune heeft ook de training-extra nodig. Oudere one-liners falen hier bij importtijd.

   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
   Authenticeren

   Accepteer de paligemma-3b-pt-224 licentie in een browser en log vervolgens in op de machine die traint.

   bash

   hf auth login

3. 3
   Kwantielstatistieken toevoegen

   Pi0.5 normaliseert STATE en ACTION met kwantielen, dus meta/stats.json heeft q01 en q99 nodig. Oudere datasets bevatten alleen min, max, gemiddelde, std.

   bash

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

4. 4
   Fine-tunen vanuit lerobot/pi05_base

   Stel de batchgrootte in op wat uw kaart aankan; de documentatie gebruikt 64 op LIBERO bij 80 GB. Geef bfloat16 expliciet door, de standaardconfiguratie 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
   Uitvoeren op de arm

   In 0.6.x is dit lerobot-rollout: lerobot-record weigert een policy en accepteert geen eval_ datasetnamen. Base stuurt de arm aan, sentry neemt de rollout op.

   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 sets standaardwaarden, en welke de trainer bereiken

openpi's TrainConfig is de referentie, LeRobot's PI05Config is wat lerobot-train gebruikt als je niets zegt, en het formulier hier stuurt een derde set. De verrassing is de leersnelheid: beide upstream defaults pieken op 2.5e-5, terwijl openpi's eigen pi05_libero config en dit platform deze verhogen naar 5e-5.

Is de poort getrouw? Het LeRobot-team heeft het LIBERO-basismodel verder 6k stappen gefine-tuned en vergeleken met openpi's referentiecijfers op vier suites: gemiddeld 97.5 procent tegen 96.85, voor op Libero 10, achter op Spatial. De route is een keuze voor tooling, niet voor kwaliteit.

De 485 ms realiteit, en waar het onbruikbaar wordt

Dit bepaalt je project, dus het komt vóór de kostentabel. De per actiestap gemeten hier voor Pi0.5 is 485 ms. Tegen de andere vier:

Upstream heeft een antwoord, en de helft ervan zit al in de release die u kunt installeren. Real-Time Chunking genereert het volgende brok terwijl de arm nog het huidige uitvoert, en leidt vervolgens de overlappende stappen van het nieuwe brok om dicht bij het reeds uitgevoerde deel te blijven, zodat de arm niet stopt of schokt bij de naad. De inferentie-tijd vorm is geleverd in de 0.4.2 changelog voor Pi0, Pi0.5 en SmolVLA en is een rollout-vlag, geen hertraining:

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

Het maakt het model niet sneller. Het verbergt de kloof: de 485 ms wordt nog steeds besteed, maar buiten het kritieke pad, zodat de wachtrij niet leeg raakt tussen brokken. De trainingstijdvariant van arXiv 2512.05964 gaat verder: het model leert te conditioneren op een schoon actievoorvoegsel, zodat bij inferentie de overlap hard wordt ingevuld met per-actie flow-tijdstappen in plaats van geleid, en de guidance backward pass verdwijnt. Tijdens de training sampelt het een voorvoegsellengte per voorbeeld en neemt het het flowverlies op de resterende postfix. Die vlag leeft alleen op main, niet in 0.6.1, en de vertraging waarvoor u traint, moet onder chunk_size blijven.

Twee manieren om een Pi0.5 checkpoint te verkrijgen

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 het niet werkt

• Dataset geweigerd: v3 vereist
• Onvoldoende geheugen tijdens training
• Verlies daalt, maar het beleid doet niets
• Beleid bevriest midden in de beweging
• Beleid werkt slechts in één opstelling
• Trainingstaak blijft in wachtrij staan

Wat één run kost

Pi0.5 bevindt zich in de dure categorie omdat het een 80 GB kaart nodig heeft, en spotprijzen fluctueren, dus het cijfer is een bereik in plaats van een vaste prijs. Voor veel SO-100 taken, train SmolVLA of ACT op de 24 GB categorie eerst, bevestig dat de taak überhaupt leerbaar is, en besteed er dan A100-uren aan. Train uw eerste beleid doorloopt die goedkopere lus, en prijzen toont de huidige categorieën.

Voordat u een avond investeert: en leggen dezelfde cijfers naast elkaar. De bevat 85 VLA-modellen met 332 benchmarkresultaten, elk gekoppeld aan de bron, en achtergrondinformatie over de familie vindt u in .