Cum să antrenezi Pi0.5 pe propriile date de robot

Pi0.5 este modelul la care apelezi atunci când o politică trebuie să funcționeze într-o încăpere pe care nu a mai văzut-o niciodată. Este, de asemenea, cea mai dificilă dintre cele cinci politici antrenabile de aici pentru a ajusta fin manual: depozitul upstream este în primul rând JAX, portul LeRobot a mutat implementarea din lerobot-record în 0.6.0 și a făcut instalarea de bază prea mică pentru antrenament, iar o ajustare fină completă nu încape pe un 4090. Mai jos: ce potrivire a fluxului costă la inferență, cele două rute de comandă și numărul de 485 ms care decide dacă rezultatul este utilizabil.

Ce este de fapt Pi0.5

Physical Intelligence a publicat pi0 în octombrie 2024: un model de viziune-limbaj-acțiune cu potrivire a fluxului, bazat pe un VLM pre-antrenat: PaliGemma cu 3 miliarde de parametri plus un expert de acțiune de 300M inițializat de la zero, un total de 3.3 miliarde. Lucrarea raportează pre-antrenament pe peste 10.000 de ore de date robotice, pe 7 configurații de roboți și 68 de sarcini. Mai multe în articolul despre pi0.

Pi0.5 (arXiv 2504.16054, 22 aprilie 2025) păstrează acel schelet și schimbă dieta de antrenament: date web, detecție de obiecte, instrucțiuni verbale de la oameni care antrenează robotul, etichete de sub-sarcini, date inter-corporale de la roboți din multe case. Rezultatul este un robot care curăță bucătării în case care nu au făcut parte din setul de antrenament. Fișierul README al openpi adaugă un detaliu pe care titlul nu îl menționează: versiunea lansată a pi0.5 a fost antrenată cu izolare de cunoștințe (arXiv 2505.23705).

Ce schimbă potrivirea fluxului în antrenament și inferență

O politică pe care o poți antrena pe un SO-100 fie regresează acțiunile direct (ACT) fie le tokenizează și le decodează autoregresiv (pi0-FAST). Potrivirea fluxului nu face niciuna dintre acestea: învață un câmp vectorial care transportă zgomotul către un bloc de acțiuni curat, apoi îl integrează. Lucrarea pi0 utilizează 10 pași de integrare cu o dimensiune a pasului de 0.1; configurația pi05 a LeRobot conține același num_inference_steps: int = 10.

• Antrenament: pierderea regresează un bloc de acțiuni zgomotos. Fără tokenizator de ajustat, fără discretizare a unghiurilor articulațiilor.
• Inferență: un bloc costă zece treceri înainte prin expertul de acțiuni. Aceasta este o problemă structurală, nu una de ajustare.
• Ieșire: acțiuni continue de dimensiune 32, umplute intern, pierderea fiind calculată pe dimensiunile pe care le are robotul tău. Un braț cu 6-grade de libertate plus un gripper utilizează 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

Backbone-ul PaliGemma și poarta din fața acestuia

PaliGemma (arXiv 2407.07726) este un codificator vizual SigLIP-So400m bazat pe un model lingvistic Gemma-2B, cu aproximativ 3 miliarde de parametri. Pi0.5 moștenește tokenizatorul său, iar acel tokenizator se află într-un depozit cu acces restricționat. Aceasta este cea mai comună modalitate prin care o primă rulare eșuează, înainte de primul pas de antrenament.

Înainte de a începe: formatul setului de date, episoade, hardware

Pi0.5 în LeRobot citește un set de date LeRobot în formatul v3.0, care a apărut odată cu lerobot 0.4.0 în octombrie 2025: multe episoade per fișier Parquet și MP4 în loc de un fișier per episod, cu limite în meta/episodes/ în loc de nume de fișiere. Înregistrați cu clientul desktop sau urmați înregistrați primul dvs. set de date și îl veți avea.

# 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 necesită cel puțin 50 de episoade pentru Pi0.5, același prag ca pentru GR00T și ACT. Pre-antrenamentul face cea mai mare parte a muncii, așa că 50 de episoade curate sunt mai bune decât 200 de episoade neglijente. Ești nou în asta? Începe cu ghidul de colectare a datelor

Ruta A: ajustare fină cu depozitul openpi

Implementarea de referință: JAX în primul rând, testată doar pe Ubuntu 22.04, ghidată de obiecte de configurare mai degrabă decât de flag-uri. O cale PyTorch a apărut în septembrie 2025, validată pe LIBERO. Trei pași: convertiți-vă datele, definiți o configurație, antrenați și serviți.

1. 1
   Clonare și instalare

   openpi utilizează uv. GIT_LFS_SKIP_SMUDGE este ceea ce permite LeRobot să fie o dependență fără blob-uri LFS.

   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
   Convertiți-vă datele într-un set de date LeRobot

   Upstream-ul livrează convertoare pentru LIBERO și DROID și se așteaptă să adaptați unul. Munca constă în maparea cheilor.

   bash

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

3. 3
   Adăugați o configurație de antrenament

   Configurațiile sunt intrări TrainConfig în src/openpi/training/config.py. Aceasta adaptează pi05_droid_finetune, cu încărcătorul de greutăți îndreptat către 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
   Calculați statisticile de normalizare

   Rulează pe baza numelui configurației, nu a setului de date. Omiterea acestuia este prima eroare clasică aici.

   bash

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

5. 5
   Antrenare

   Variabila permite JAX să utilizeze 90 la sută din memoria GPU în loc de valoarea implicită de 75. Pe o placă de 80 GB, acest lucru decide dacă rularea supraviețuiește.

   bash

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

6. 6
   Serviți-o

   Serverul ascultă pe portul 8000 și răspunde la interogările de observație; runtime-ul robotului dumneavoastră este clientul.

   bash

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

Ruta B: ajustare fină cu lerobot pi05

Portul LeRobot încapsulează aceleași ponderi în CLI-ul pe care îl utilizați deja pentru ACT și SmolVLA. Tot ce urmează a fost verificat cu lerobot 0.6.1, versiunea lansată pe 3 august 2026, și documentația pi05 din 23 august 2026. Versiunile contează aici: seturile de date v3.0 au apărut cu 0.4.0 în octombrie 2025, blogul 0.5.0 din 9 martie 2026 prezintă pi0-FAST și Real-Time Chunking, iar 0.6.0 din 6 iulie 2026 a făcut pachetul de bază ușor și a mutat implementarea la lerobot-rollout.

Un lucru nu s-a schimbat: lerobot-train și lerobot-record erau deja puncte de intrare în 0.3.2, august 2025. Un tutorial care încă apelează python -m lerobot.scripts.train este anterior unui an de modificări și merită să fie privit cu neîncredere și în rest.

1. 1
   Instalare cu extra-urile corecte

   Începând cu versiunea 0.6.0, instalarea de bază include doar dependențele ML esențiale, iar extra-ul pi nu adaugă cod pentru setul de date sau antrenament, astfel încât o ajustare fină necesită și extra-ul de antrenament. Comenzile mai vechi eșuează aici la 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
   Autentificare

   Acceptați licența paligemma-3b-pt-224 într-un browser, apoi conectați-vă pe mașina care efectuează antrenamentul.

   bash

   hf auth login

3. 3
   Adăugați statistici de cuantili

   Pi0.5 normalizează STATE și ACTION cu cuantili, deci meta/stats.json necesită q01 și q99. Seturile de date mai vechi conțin doar 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
   Ajustare fină de la lerobot/pi05_base

   Setați dimensiunea lotului la ceea ce suportă placa dvs.; documentația utilizează 64 pe LIBERO la 80 GB. Transmiteți bfloat16 explicit, valoarea implicită a configurației este 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
   Rulați-l pe braț

   În 0.6.x, aceasta este lerobot-rollout: lerobot-record refuză o politică și respinge numele seturilor de date eval_. Base controlează brațul, sentry înregistrează rularea.

   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

Trei seturi de valori implicite și care dintre ele ajung la antrenor

TrainConfig de la openpi este referința, PI05Config de la LeRobot este ceea ce folosește lerobot-train când nu specificați nimic, iar formularul de aici trimite un al treilea set. Surpriza este rata de învățare: ambele valori implicite upstream ating un vârf de 2.5e-5, în timp ce configurația pi05_libero a openpi și această platformă o ridică la 5e-5.

Este portarea fidelă? Echipa LeRobot a ajustat fin modelul de bază LIBERO pentru încă 6k pași și a comparat cu numerele de referință ale openpi pe patru suite: o medie de 97.5 procente față de 96.85, în față pe Libero 10, în urmă pe Spatial. Ruta este o alegere de instrumente, nu una de calitate.

Realitatea de 485 ms și punctul în care devine inutilizabilă

Acest lucru decide proiectul dumneavoastră, așadar precede tabelul de costuri. pe pas de acțiune măsurată aici pentru Pi0.5 este de 485 ms. Comparativ cu celelalte patru:

Upstream are un răspuns, iar jumătate din el este deja în versiunea pe care o puteți instala. Real-Time Chunking generează următorul segment în timp ce brațul execută încă pe cel curent, apoi ghidează pașii suprapuși ai noului segment pentru a rămâne aproape de partea deja executată, astfel încât brațul să nu se blocheze sau să smucească la îmbinare. Forma de inferență la timp real a fost inclusă în changelog-ul 0.4.2 pentru Pi0, Pi0.5 și SmolVLA și este un flag de rollout, nu o reantrenare:

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

Nu face modelul mai rapid. Ascunde decalajul: cele 485 ms sunt încă cheltuite, dar în afara căii critice, astfel încât coada nu se golește între segmente. Varianta de antrenament din arXiv 2512.05964 merge mai departe: modelul învață să se condiționeze pe un prefix de acțiune curat, astfel încât la inferență suprapunerea este completată forțat cu pași de timp de flux per acțiune în loc să fie ghidată, iar trecerea înapoi a ghidării dispare. În timpul antrenamentului, eșantionează o lungime de prefix per exemplu și calculează pierderea de flux pe postfixul rămas. Acest flag există doar pe ramura principală (main), nu în 0.6.1, iar întârzierea pentru care antrenați trebuie să rămână sub chunk_size.

Două moduri de a obține un 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

Când nu funcționează

• Set de date respins: v3 necesar
• Memorie insuficientă în timpul antrenamentului
• Pierderea scade, dar politica nu face nimic
• Politica se blochează în mijlocul mișcării
• Politica funcționează doar într-o singură configurație
• Jobul de antrenament blocat în coadă

Cât costă o singură rulare

Pi0.5 se încadrează în nivelul scump deoarece necesită o placă de 80 GB, iar prețurile spot fluctuează, astfel încât cifra este o plajă, nu un preț. Pentru multe sarcini SO-100, antrenați SmolVLA sau ACT pe nivelul de 24 GB mai întâi, confirmați că sarcina este deloc învățabilă, apoi petreceți ore A100 pe ea. Antrenați-vă prima politică parcurge acea buclă mai ieftină, iar prețurile conțin nivelurile curente.

Înainte de a dedica o seară: GR00T N1.7 versus Pi0.5 și Pi0.5 versus SmolVLA prezintă aceleași numere cap la cap. Arena conține 85 de modele VLA cu 332 de rezultate de benchmark, fiecare legat de sursa sa, iar informații de fond despre familie se găsesc în prezentarea noastră generală a VLA.