Jak trénovat Pi0.5 na vlastních robotických datech

Pi0.5 je model, po kterém sáhnete, když má politika fungovat v místnosti, kterou nikdy neviděla. Je to také nejobtížnější z pěti trénovatelných politik zde k jemnému doladění ručně: upstreamový repozitář je primárně JAX, port LeRobot přesunul nasazení mimo lerobot-record v 0.6.0 a zmenšil základní instalaci natolik, že s ní nelze trénovat, a plné jemné doladění se nevejde na 4090. Níže: co párování toků stojí při inferenci, dvě cesty příkazů a číslo 485 ms, které rozhoduje, zda je výsledek použitelný.

Co Pi0.5 skutečně je

Physical Intelligence publikovala pi0 v říjnu 2024: model s párováním toků model vize-jazyk-akce na předtrénovaném VLM: PaliGemma s 3 miliardami parametrů plus 300M akční expert inicializovaný od nuly, celkem 3.3 miliardy. Článek uvádí předtrénování na více než 10 000 hodinách robotických dat napříč 7 konfiguracemi robotů a 68 úkoly. Více v článku o pi0.

Pi0.5 (arXiv 2504.16054, 22. dubna 2025) si zachovává tuto kostru a mění tréninkovou dietu: webová data, detekce objektů, verbální instrukce od lidí koučujících robota, štítky podúkolů, data napříč ztělesněními od robotů v mnoha domácnostech. Výsledkem je robot uklízející kuchyně v domech, které nebyly v tréninkové sadě. openpi README dodává detail, který název neuvádí: vydaný pi0.5 byl trénován s knowledge insulation (arXiv 2505.23705).

Co flow matching mění na tréninku a inferenci

A politika kterou můžete trénovat na SO-100, buď přímo regresuje akce (ACT) nebo je tokenizuje a dekóduje autoregresivně (pi0-FAST). Flow matching nedělá ani jedno: učí se vektorové pole, které transportuje šum do čistého akčního bloku, a poté jej integruje. Článek o pi0 používá 10 integračních kroků s velikostí kroku 0.1; konfigurace pi05 LeRobota nese stejné num_inference_steps: int = 10.

• Trénink: ztráta regresuje zašuměný akční blok. Žádný tokenizer k ladění, žádná diskretizace vašich kloubních úhlů.
• Inference: jeden blok stojí deset průchodů vpřed akčním expertem. To je strukturální, nikoli problém ladění.
• Výstup: spojité akce dimenze 32, interně vyplněné, ztráta se počítá na dimenzích, které má váš robot. 6-DoF rameno plus chapadlo používá 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 páteř a brána před ní

PaliGemma (arXiv 2407.07726) je SigLIP-So400m vizuální kodér na jazykovém modelu Gemma-2B, s přibližně 3B parametry. Pi0.5 dědí svůj tokenizér, a tento tokenizér se nachází v řízeném repozitáři. Toto je nejčastější způsob, jak první spuštění selže, ještě před prvním tréninkovým krokem.

Než začnete: formát datové sady, epizody, hardware

Pi0.5 v LeRobotu čte datovou sadu LeRobot v rozložení v3.0, které přišlo s lerobot 0.4.0 v říjnu 2025: mnoho epizod na soubor Parquet a MP4 namísto jednoho souboru na epizodu, s hranicemi v meta/episodes/ namísto názvů souborů. Nahrávejte pomocí desktopového klienta nebo postupujte podle nahrajte svou první datovou sadu a máte to.

# 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

Platforma vyžaduje alespoň 50 epizod pro Pi0.5, což je stejný základ jako pro GR00T a ACT. Předtrénink dělá tu nejtěžší práci, takže 50 čistých epizod je lepší než 200 nedbalých. Jste v tom noví? Začněte s průvodcem sběrem dat.

Cesta A: jemné doladění s repozitářem openpi

Referenční implementace: nejprve JAX, testováno pouze na Ubuntu 22.04, řízeno konfiguračními objekty spíše než příznaky. Cesta PyTorch dorazila v září 2025, ověřeno na LIBERO. Tři kroky: konverze dat, definice konfigurace, trénování a obsluha.

1. 1
   Klonování a instalace

   openpi používá uv. GIT_LFS_SKIP_SMUDGE umožňuje, aby LeRobot fungoval jako závislost bez LFS blobů.

   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
   Převeďte svá data na datovou sadu LeRobot

   Upstream dodává konvertory pro LIBERO a DROID a očekává, že si jeden přizpůsobíte. Práce spočívá v mapování klíčů.

   bash

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

3. 3
   Přidat tréninkovou konfiguraci

   Konfigurace jsou položky TrainConfig v src/openpi/training/config.py. Tato adaptuje pi05_droid_finetune, s načítáním vah směřujícím na 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
   Vypočítat normální statistiky

   Spouští se proti názvu konfigurace, nikoli datové sadě. Přeskočení je zde klasickou první chybou.

   bash

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

5. 5
   Trénovat

   Proměnná umožňuje JAXu použít 90 procent paměti GPU namísto výchozích 75. Na 80 GB kartě to rozhoduje o tom, zda běh přežije.

   bash

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

6. 6
   Obsloužit

   Server naslouchá na portu 8000 a odpovídá na dotazy ohledně pozorování; běh vašeho robota je klientem.

   bash

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

Cesta B: jemné ladění s lerobot pi05

Port LeRobot obaluje stejné váhy v CLI, které již používáte pro ACT a SmolVLA. Vše níže bylo zkontrolováno proti lerobot 0.6.1, vydání od 3. srpna 2026, a dokumentaci pi05 z 23. srpna 2026. Verze jsou zde důležité: datové sady v3.0 dorazily s 0.4.0 v říjnu 2025, blog 0.5.0 z 9. března 2026 představuje pi0-FAST a Real-Time Chunking, a 0.6.0 ze 6. července 2026 odlehčilo základní balíček a přesunulo nasazení na lerobot-rollout.

Jedna věc se nezměnila: lerobot-train a lerobot-record byly již vstupními body v 0.3.2, srpen 2025. Tutoriál, který stále volá python -m lerobot.scripts.train, předchází rok změn a je nedůvěryhodný i v ostatních ohledech.

1. 1
   Instalace se správnými doplňky

   Od verze 0.6.0 základní instalace obsahuje pouze základní ML závislosti a doplněk pi nepřidává žádný kód pro datovou sadu ani trénování, takže pro jemné doladění je potřeba i doplněk pro trénování. Starší jednořádkové příkazy zde selžou při importu.

   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
   Ověření

   Přijměte licenci paligemma-3b-pt-224 v prohlížeči a poté se přihlaste na stroji, který provádí trénování.

   bash

   hf auth login

3. 3
   Přidat kvantilové statistiky

   Pi0.5 normalizuje STATE a ACTION pomocí kvantilů, takže meta/stats.json potřebuje q01 a q99. Starší datové sady obsahují pouze min, max, mean, std.

   bash

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

4. 4
   Jemné doladění z lerobot/pi05_base

   Nastavte velikost dávky tak, aby ji vaše karta zvládla; dokumentace používá 64 na LIBERO s 80 GB. Explicitně předejte bfloat16, výchozí hodnota konfigurace je 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
   Spusťte to na rameni

   Ve verzi 0.6.x je to lerobot-rollout: lerobot-record odmítá politiku a zamítá názvy datových sad eval_. Base řídí rameno, sentry zaznamenává průběh.

   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

Tři sady výchozích nastavení a které z nich se dostanou k trénovacímu modulu

TrainConfig od openpi je referencí, PI05Config od LeRobot je to, co lerobot-train používá, když nic neřeknete, a formulář zde odesílá třetí sadu. Překvapením je rychlost učení: oba výchozí upstreamové hodnoty dosahují vrcholu 2.5e-5, zatímco vlastní konfigurace pi05_libero od openpi a tato platforma ji zvyšují na 5e-5.

Je port věrný? Tým LeRobot doladil základní model LIBERO o dalších 6k kroků a porovnal ho s referenčními čísly openpi na čtyřech sadách: průměr 97.5 procenta oproti 96.85, lepší na Libero 10, horší na Spatial. Tato cesta je volbou nástrojů, nikoli volbou kvality.

Realita 485 ms a kde přestává být použitelná

To rozhoduje o vašem projektu, takže to přichází před tabulkou nákladů. na krok akce naměřená zde pro Pi0.5 je 485 ms. Proti ostatním čtyřem:

Upstream má odpověď a polovina z ní je již v vydání, které si můžete nainstalovat. Real-Time Chunking generuje další blok, zatímco rameno stále provádí ten aktuální, a poté navádí překrývající se kroky nového bloku, aby zůstaly blízko již provedené části, takže se rameno nezastaví ani necukne ve spoji. Forma pro dobu inference byla dodána v changelogu 0.4.2 pro Pi0, Pi0.5 a SmolVLA a je to příznak pro nasazení, nikoli pro přeškolení:

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

Nezrychluje to model. Skrývá to mezeru: 485 ms je stále spotřebováno, ale mimo kritickou cestu, takže fronta mezi bloky nevyschne. Varianta z doby tréninku z arXiv 2512.05964 jde dál: model se učí podmiňovat se na čistý akční prefix, takže při inferenci je překrytí pevně 'inpainted' s časovými kroky toku pro každou akci namísto navádění, a zpětný průchod navádění zmizí. Během tréninku vzorkuje délku prefixu pro každý příklad a počítá ztrátu toku na zbývajícím postfixu. Tento příznak je pouze v hlavní větvi, nikoli ve verzi 0.6.1, a zpoždění, pro které trénujete, musí zůstat pod chunk_size.

Dva způsoby, jak získat checkpoint Pi0.5

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

Když to nefunguje

• Datová sada zamítnuta: vyžadována v3
• Nedostatek paměti během tréninku
• Ztráta klesá, ale politika nic nedělá
• Politika zamrzá uprostřed pohybu
• Politika funguje pouze v jednom nastavení
• Tréninková úloha uvízla ve frontě

Co stojí jeden běh

Pi0.5 spadá do drahé úrovně, protože potřebuje 80 GB kartu a spotové ceny se mění, takže údaj je spíše rozsah než pevná cena. Pro mnoho úloh SO-100 trénujte SmolVLA nebo ACT nejprve na 24 GB úrovni, ověřte, zda je úloha vůbec naučitelná, a teprve poté na ni vynaložte hodiny A100. Trénujte svou první politiku popisuje tento levnější cyklus, a ceník obsahuje aktuální úrovně.

Než se zavážete na celý večer: GR00T N1.7 proti Pi0.5 a Pi0.5 proti SmolVLA porovnávají stejná čísla přímo. Aréna obsahuje 85 VLA modelů s 332 výsledky benchmarků, každý s odkazem na svůj zdroj, a pozadí rodiny je v našem přehledu VLA.