Wie man Pi0.5 mit eigenen Roboterdaten trainiert

Pi0.5 ist das Modell der Wahl, wenn eine Policy in einem Raum funktionieren muss, den sie noch nie zuvor gesehen hat. Es ist auch das umständlichste der fünf trainierbaren Policies hier, um manuell feinabzustimmen: Das Upstream-Repository ist primär JAX, der LeRobot-Port hat die Bereitstellung in 0.6.0 aus lerobot-record verschoben und die Basisinstallation zu klein gemacht, um damit zu trainieren, und ein vollständiges Fine-Tuning passt nicht auf eine 4090. Unten: was Flow Matching bei der Inferenz kostet, die beiden Befehlsrouten und die Zahl von 485 ms, die entscheidet, ob das Ergebnis nutzbar ist.

Was Pi0.5 tatsächlich ist

Physical Intelligence veröffentlichte pi0 im Oktober 2024: ein Flow-Matching Vision-Sprache-Aktions-Modell auf einem vortrainierten VLM: PaliGemma mit 3 Milliarden Parametern plus einem 300M Action Expert, der von Grund auf initialisiert wurde, insgesamt 3.3 Milliarden. Das Paper berichtet über ein Vortraining mit über 10.000 Stunden Robotikdaten über 7 Roboterkonfigurationen und 68 Aufgaben hinweg. Mehr dazu im pi0-Artikel.

Pi0.5 (arXiv 2504.16054, 22. April 2025) behält dieses Skelett bei und ändert die Trainingsdiät: Webdaten, Objekterkennung, verbale Anweisungen von Menschen, die den Roboter coachen, Unteraufgaben-Labels, Cross-Embodiment-Daten von Robotern in vielen Haushalten. Das Ergebnis ist ein Roboter, der Küchen in Häusern reinigt, die nicht im Trainingsdatensatz waren. Die openpi README fügt ein Detail hinzu, das der Titel nicht enthält: Das veröffentlichte pi0.5 wurde mit Wissensisolation (arXiv 2505.23705) trainiert.

Was Flow Matching an Training und Inferenz ändert

Eine Policy die Sie auf einem SO-100 trainieren können, regrediert entweder Aktionen direkt (ACT) oder tokenisiert sie und dekodiert autoregressiv (pi0-FAST). Flow Matching tut keines von beidem: Es lernt ein Vektorfeld, das Rauschen zu einem sauberen Aktions-Chunk, und integriert es dann. Das pi0-Paper verwendet 10 Integrationsschritte mit einer Schrittgröße von 0.1; LeRobots pi05-Konfiguration enthält dieselbe num_inference_steps: int = 10.

• Training: Der Verlust regrediert einen verrauschten Aktions-Chunk. Kein Tokenizer zum Abstimmen, keine Diskretisierung Ihrer Gelenkwinkel.
• Inferenz: Ein Chunk kostet zehn Vorwärtsdurchläufe durch den Aktions-Experten. Das ist strukturell, kein Abstimmungsproblem.
• Ausgabe: Kontinuierliche Aktionen der Dimension 32, intern aufgefüllt, Verlust wird auf den Dimensionen berechnet, die Ihr Roboter hat. Ein 6-DoF-Arm plus Greifer verwendet 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

Das PaliGemma-Backbone und das Gate davor

PaliGemma (arXiv 2407.07726) ist ein SigLIP-So400m Vision-Encoder auf einem Gemma-2B Sprachmodell mit etwa 3 Milliarden Parametern. Pi0.5 erbt seinen Tokenizer, und dieser Tokenizer befindet sich in einem geschützten Repository. Dies ist der häufigste Grund, warum ein erster Durchlauf scheitert, noch vor dem ersten Trainingsschritt.

Bevor Sie beginnen: Datensatzformat, Episoden, Hardware

Pi0.5 in LeRobot liest einen LeRobot-Datensatz im v3.0-Layout, das mit lerobot 0.4.0 im Oktober 2025 eingeführt wurde: viele Episoden pro Parquet- und MP4-Datei anstelle einer Datei pro Episode, mit Begrenzungen in meta/episodes/ anstatt in Dateinamen. Nehmen Sie mit dem Desktop-Client auf oder folgen Sie Aufnahme Ihres ersten Datensatzes und Sie haben es.

# 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

Die Plattform benötigt mindestens 50 Episoden für Pi0.5, die gleiche Untergrenze wie für GR00T und ACT. Das Vortraining leistet die Hauptarbeit, daher sind 50 saubere Episoden besser als 200 schlampige. Neu hier? Beginnen Sie mit dem Leitfaden zur Datenerfassung.

Route A: Feinabstimmung mit dem openpi-Repository

Die Referenzimplementierung: Zuerst JAX, nur unter Ubuntu 22.04 getestet, gesteuert durch Konfigurationsobjekte statt Flags. Ein PyTorch-Pfad kam im September 2025, validiert auf LIBERO. Drei Schritte: Daten konvertieren, Konfiguration definieren, trainieren und bereitstellen.

1. 1
   Klonen und installieren

   openpi verwendet uv. GIT_LFS_SKIP_SMUDGE ermöglicht es LeRobot, als Abhängigkeit ohne LFS-Blobs zu fungieren.

   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
   Ihre Daten in ein LeRobot-Dataset konvertieren

   Upstream liefert Konverter für LIBERO und DROID und erwartet, dass Sie einen davon anpassen. Die Arbeit besteht in der Schlüsselzuordnung.

   bash

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

3. 3
   Eine Trainingskonfiguration hinzufügen

   Konfigurationen sind TrainConfig-Einträge in src/openpi/training/config.py. Diese hier passt pi05_droid_finetune an, wobei der Weight Loader auf pi05_base zeigt.

   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
   Normierungsstatistiken berechnen

   Läuft gegen den Konfigurationsnamen, nicht gegen das Dataset. Diesen Schritt zu überspringen, ist hier der klassische erste Fehler.

   bash

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

5. 5
   Trainieren

   Die Variable lässt JAX 90 Prozent des GPU-Speichers nutzen, anstatt der standardmäßigen 75. Auf einer 80-GB-Karte entscheidet dies, ob der Lauf überlebt.

   bash

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

6. 6
   Bereitstellen

   Der Server lauscht auf Port 8000 und beantwortet Beobachtungsanfragen; Ihre Roboter-Laufzeitumgebung ist der 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-Tuning mit lerobot pi05

Der LeRobot-Port kapselt dieselben Gewichte in der CLI, die Sie bereits für ACT und SmolVLA. Alles Folgende wurde mit lerobot 0.6.1, der Veröffentlichung vom 3. August 2026, und den pi05-Dokumenten vom 23. August 2026 überprüft. Versionen sind hier wichtig: v3.0-Datensätze kamen mit 0.4.0 im Oktober 2025, der 0.5.0-Blog vom 9. März 2026 stellt pi0-FAST und Real-Time Chunking vor, und 0.6.0 vom 6. Juli 2026 machte das Basispaket leichtgewichtig und verlagerte die Bereitstellung auf lerobot-rollout.

Eines hat sich nicht geändert: lerobot-train und lerobot-record waren bereits in 0.3.2, August 2025, Einstiegspunkte. Ein Tutorial, das immer noch python -m lerobot.scripts.train aufruft, ist älter als ein Jahr voller Änderungen und sollte auch im Übrigen misstrauisch betrachtet werden.

1. 1
   Installation mit den richtigen Extras

   Seit 0.6.0 enthält die Basisinstallation nur die Kern-ML-Abhängigkeiten, und das Pi-Extra fügt keinen Datensatz- oder Trainingscode hinzu, daher benötigt ein Fine-Tuning auch das Trainings-Extra. Ältere Einzeiler schlagen hier zur Importzeit fehl.

   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
   Authentifizieren

   Akzeptieren Sie die paligemma-3b-pt-224-Lizenz in einem Browser und melden Sie sich dann auf der Trainingsmaschine an.

   bash

   hf auth login

3. 3
   Quantilstatistiken hinzufügen

   Pi0.5 normalisiert STATE und ACTION mit Quantilen, daher benötigt meta/stats.json q01 und q99. Ältere Datensätze enthalten nur 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
   Fine-Tuning von lerobot/pi05_base

   Stellen Sie die Batch-Größe so ein, dass Ihre Karte damit zurechtkommt; die Dokumentation verwendet 64 auf LIBERO bei 80 GB. Übergeben Sie bfloat16 explizit, der Standardwert der Konfiguration ist 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
   Auf dem Arm ausführen

   In 0.6.x ist dies lerobot-rollout: lerobot-record lehnt eine Policy ab und weist eval_-Datensatznamen zurück. Base steuert den Arm, sentry zeichnet den Rollout auf.

   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

Drei Sätze von Standardwerten und welche davon den Trainer erreichen

openpis TrainConfig ist die Referenz, LeRobots PI05Config wird von lerobot-train verwendet, wenn Sie nichts angeben, und das Formular hier sendet einen dritten Satz. Die Überraschung ist die Lernrate: Beide Upstream-Standardwerte erreichen 2.5e-5, während openpis eigene pi05_libero Konfiguration und diese Plattform sie auf 5e-5 erhöhen.

Ist der Port originalgetreu? Das LeRobot-Team hat das LIBERO-Basismodell für weitere 6k Schritte feinabgestimmt und mit den Referenzzahlen von openpi auf vier Suiten verglichen: 97.5 Prozent im Durchschnitt gegenüber 96.85, vorne bei Libero 10, hinten bei Spatial. Die Route ist eine Werkzeugwahl, keine Qualitätswahl.

Die 485 ms Realität und wo sie unbrauchbar wird

Dies entscheidet über Ihr Projekt, daher steht es vor der Kostentabelle. Die pro Aktionsschritt, hier für Pi0.5 gemessen, beträgt 485 ms. Im Vergleich zu den anderen vier:

Upstream hat eine Antwort, und die Hälfte davon ist bereits in der Release enthalten, die Sie installieren können. Real-Time Chunking generiert den nächsten Chunk, während der Arm noch den aktuellen ausführt, und führt dann die überlappenden Schritte des neuen Chunks so, dass sie nahe am bereits ausgeführten Teil bleiben, damit der Arm an der Nahtstelle nicht stoppt oder ruckelt. Die Inferenz-Zeit-Form wurde im 0.4.2 Changelog für Pi0, Pi0.5 und SmolVLA ausgeliefert und ist ein Rollout-Flag, kein Retrain:

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

Es macht das Modell nicht schneller. Es verbirgt die Lücke: Die 485 ms werden immer noch aufgewendet, aber außerhalb des kritischen Pfades, sodass die Warteschlange zwischen den Chunks nicht leerläuft. Die Trainingszeit-Variante von arXiv 2512.05964 geht noch weiter: Das Modell lernt, sich an ein sauberes Aktionspräfix zu konditionieren, sodass bei der Inferenz die Überlappung mit aktionsspezifischen Fluss-Zeitschritten hart eingefärbt wird, anstatt geführt zu werden, und der Guidance-Rückwärtspass verschwindet. Während des Trainings wird pro Beispiel eine Präfixlänge abgetastet und der Flussverlust auf dem verbleibenden Postfix berechnet. Dieses Flag existiert nur im Main-Branch, nicht in 0.6.1, und die Verzögerung, für die Sie trainieren, muss unter chunk_size bleiben.

Zwei Wege, einen Pi0.5-Checkpoint zu erhalten

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

Wenn es nicht funktioniert

• Datensatz abgelehnt: v3 erforderlich
• Speicherüberlauf während des Trainings
• Verlust sinkt, aber die Policy tut nichts
• Policy friert mitten in der Bewegung ein
• Policy funktioniert nur in einem Setup
• Trainingsjob in Warteschlange festgefahren

Was ein Durchlauf kostet

Pi0.5 befindet sich in der teuren Stufe, da es eine 80-GB-Karte benötigt und die Spotpreise schwanken, sodass die Angabe eher eine Spanne als ein fester Preis ist. Für viele SO-100-Aufgaben trainieren Sie zunächst SmolVLA oder ACT auf der 24-GB-Stufe, um zu bestätigen, dass die Aufgabe überhaupt erlernbar ist, und investieren Sie dann A100-Stunden dafür. Trainieren Sie Ihre erste Policy beschreibt diesen günstigeren Ablauf, und Preise enthält die aktuellen Stufen.

Bevor Sie einen Abend investieren: und legen die gleichen Zahlen direkt gegenüber. Die enthält 85 VLA-Modelle mit 332 Benchmark-Ergebnissen, jedes mit seiner Quelle verknüpft, und Hintergrundinformationen zur Familie finden Sie in .