Come Addestrare Pi0.5 sui Tuoi Dati Robotici

Pi0.5 è il modello a cui si ricorre quando una policy deve funzionare in una stanza che non ha mai visto. È anche il più ostico dei cinque policy addestrabili qui per effettuare il fine-tuning manualmente: il repository upstream è JAX-first, il porting LeRobot ha spostato il deployment fuori da lerobot-record in 0.6.0 e ha reso l'installazione base troppo piccola per l'addestramento, e un fine-tuning completo non si adatta a una 4090. Di seguito: cosa flow matching costa in inferenza, le due vie di comando e il numero di 485 ms che decide se il risultato è utilizzabile.

Cos'è realmente Pi0.5

Physical Intelligence ha pubblicato pi0 nell'ottobre 2024: un modello visione-linguaggio-azione con flow matching basato su un VLM pre-addestrato: PaliGemma con 3 miliardi di parametri più un esperto di azioni da 300M inizializzato da zero, per un totale di 3.3 miliardi. Il paper riporta un pre-addestramento su oltre 10.000 ore di dati robotici attraverso 7 configurazioni di robot e 68 task. Maggiori informazioni in l'articolo su pi0.

Pi0.5 (arXiv 2504.16054, 22 April 2025) mantiene quello scheletro e cambia la dieta di addestramento: dati web, rilevamento di oggetti, istruzioni verbali da umani che addestrano il robot, etichette di sottocompiti, dati cross-embodiment da robot in molte case. Il risultato è un robot che pulisce cucine in case che non facevano parte del set di addestramento. Il README di openpi aggiunge un dettaglio che il titolo non menziona: il pi0.5 rilasciato è stato addestrato con isolamento della conoscenza (arXiv 2505.23705).

Cosa cambia il flow matching nell'addestramento e nell'inferenza

Una policy che puoi addestrare su un SO-100 o regredisce le azioni direttamente (ACT) o le tokenizza e le decodifica autoregressivamente (pi0-FAST). Il flow matching non fa nessuna delle due cose: impara un campo vettoriale che trasporta il rumore a un chunk di azione pulito, quindi lo integra. Il paper pi0 utilizza 10 passi di integrazione con dimensione del passo 0.1; la configurazione pi05 di LeRobot mantiene lo stesso num_inference_steps: int = 10.

• Addestramento: la loss regredisce un chunk di azione rumoroso. Nessun tokenizer da ottimizzare, nessuna discretizzazione degli angoli delle tue articolazioni.
• Inferenza: un chunk costa dieci passaggi in avanti attraverso l'esperto di azione. Questo è strutturale, non un problema di ottimizzazione.
• Output: azioni continue di dimensione 32, riempite internamente, loss calcolata sulle dimensioni che il tuo robot possiede. Un braccio a 6-DoF più pinza ne usa 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

Il backbone PaliGemma e il gate di fronte ad esso

PaliGemma (arXiv 2407.07726) è un encoder di visione SigLIP-So400m basato su un modello linguistico Gemma-2B, con circa 3 miliardi di parametri. Pi0.5 eredita il suo tokenizer, e quel tokenizer si trova in un repository con accesso controllato. Questo è il modo più comune in cui una prima esecuzione fallisce, prima del primo passo di addestramento.

Prima di iniziare: formato del dataset, episodi, hardware

Pi0.5 in LeRobot legge un dataset LeRobot in formato v3.0, introdotto con lerobot 0.4.0 nell'ottobre 2025: molti episodi per file Parquet e MP4 invece di un file per episodio, con i confini in meta/episodes/ anziché nei nomi dei file. Registra con il client desktop o segui registra il tuo primo dataset e lo avrai.

# 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

La piattaforma richiede almeno 50 episodi per Pi0.5, lo stesso minimo di GR00T e ACT. Il pre-addestramento fa il grosso del lavoro, quindi 50 episodi puliti sono meglio di 200 approssimativi. Sei nuovo in questo? Inizia con la guida alla raccolta dati.

Percorso A: ottimizzazione con il repository openpi

L'implementazione di riferimento: JAX prima, testata solo su Ubuntu 22.04, guidata da oggetti di configurazione piuttosto che da flag. Un percorso PyTorch è arrivato a settembre 2025, convalidato su LIBERO. Tre passaggi: convertire i dati, definire una configurazione, addestrare e servire.

1. 1
   Clona e installa

   openpi utilizza uv. GIT_LFS_SKIP_SMUDGE è ciò che permette a LeRobot di essere una dipendenza senza blob 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 tuoi dati in un dataset LeRobot

   L'upstream fornisce convertitori per LIBERO e DROID e si aspetta che tu ne adatti uno. Il lavoro consiste nella mappatura delle chiavi.

   bash

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

3. 3
   Aggiungi una configurazione di addestramento

   Le configurazioni sono voci TrainConfig in src/openpi/training/config.py. Questa adatta pi05_droid_finetune, con il caricatore dei pesi puntato a 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
   Calcola le statistiche di normalizzazione

   Viene eseguito rispetto al nome della configurazione, non al dataset. Saltarlo è il classico primo errore qui.

   bash

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

5. 5
   Addestra

   La variabile consente a JAX di utilizzare il 90 percento della memoria GPU invece del 75 predefinito. Su una scheda da 80 GB, questo decide se l'esecuzione sopravvive.

   bash

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

6. 6
   Servilo

   Il server ascolta sulla porta 8000 e risponde alle query di osservazione; il runtime del tuo robot è il client.

   bash

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

Percorso B: fine-tuning con lerobot pi05

La porta LeRobot racchiude gli stessi pesi nella CLI che già usi per ACT e SmolVLA. Tutto ciò che segue è stato verificato rispetto a lerobot 0.6.1, la release del 3 agosto 2026, e la documentazione di pi05 del 23 agosto 2026. Le versioni contano qui: i dataset v3.0 sono arrivati con la 0.4.0 nell'ottobre 2025, il blog 0.5.0 del 9 marzo 2026 presenta pi0-FAST e Real-Time Chunking, e la 0.6.0 del 6 luglio 2026 ha reso il pacchetto base leggero e ha spostato il deployment su lerobot-rollout.

Una cosa non è cambiata: lerobot-train e lerobot-record erano già entry point nella versione 0.3.2, agosto 2025. Un tutorial che chiama ancora python -m lerobot.scripts.train precede un anno di cambiamenti e merita di essere diffidato anche per il resto.

1. 1
   Installazione con gli extra corretti

   Dalla versione 0.6.0, l'installazione base include solo le dipendenze ML principali, e l'extra 'pi' non aggiunge codice per dataset o training, quindi un fine-tuning richiede anche l'extra 'training'. Le vecchie istruzioni a riga singola falliscono qui al momento dell'importazione.

   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
   Autenticazione

   Accetta la licenza paligemma-3b-pt-224 in un browser, quindi accedi sulla macchina che esegue il training.

   bash

   hf auth login

3. 3
   Aggiungi statistiche sui quantili

   Pi0.5 normalizza STATE e ACTION con i quantili, quindi meta/stats.json richiede q01 e q99. I dataset più vecchi contengono solo 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 da lerobot/pi05_base

   Imposta la dimensione del batch a quanto la tua scheda può gestire; la documentazione usa 64 su LIBERO a 80 GB. Passa bfloat16 esplicitamente, il default della configurazione è 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
   Eseguilo sul braccio

   Nella versione 0.6.x questo è lerobot-rollout: lerobot-record rifiuta una policy e i nomi dei dataset eval_. Base controlla il braccio, sentry registra il rollout.

   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 set di default, e quali raggiungono il trainer

TrainConfig di openpi è il riferimento, PI05Config di LeRobot è ciò che lerobot-train usa quando non si specifica nulla, e il modulo qui invia un terzo set. La sorpresa è il tasso di apprendimento: entrambi i valori predefiniti a monte raggiungono un picco di 2.5e-5, mentre la configurazione pi05_libero di openpi e questa piattaforma lo aumentano a 5e-5.

La portabilità è fedele? Il team di LeRobot ha ottimizzato il modello base LIBERO per ulteriori 6k passi e ha confrontato i risultati con i numeri di riferimento di openpi su quattro suite: 97.5 percento di media contro 96.85, in vantaggio su Libero 10, in svantaggio su Spatial. Il percorso è una scelta di strumenti, non di qualità.

La realtà dei 485 ms e dove smette di essere utilizzabile

Questo decide il tuo progetto, quindi viene prima della tabella dei costi. La per passo d'azione misurata qui per Pi0.5 è di 485 ms. Contro gli altri quattro:

L'upstream ha una risposta, e metà di essa è già nella release che puoi installare. Il Real-Time Chunking genera il chunk successivo mentre il braccio sta ancora eseguendo quello attuale, quindi guida i passi sovrapposti del nuovo chunk a rimanere vicini alla parte già eseguita, in modo che il braccio non si blocchi o scatti alla giunzione. La forma a tempo di inferenza è stata inclusa nel changelog 0.4.2 per Pi0, Pi0.5 e SmolVLA ed è un flag di rollout, non un 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

Non rende il modello più veloce. Nasconde il divario: i 485 ms vengono comunque spesi, ma fuori dal percorso critico, in modo che la coda non si esaurisca tra i chunk. La variante a tempo di training da arXiv 2512.05964 va oltre: il modello impara a condizionare su un prefisso d'azione pulito, quindi all'inferenza la sovrapposizione viene hard-inpainted con timestep di flusso per azione invece di essere guidata, e il passaggio all'indietro della guida scompare. Durante il training, campiona una lunghezza di prefisso per esempio e calcola la perdita di flusso sul suffisso rimanente. Quel flag è presente solo su main, non in 0.6.1, e il ritardo per cui si effettua il training deve rimanere al di sotto di chunk_size.

Due modi per ottenere 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

Quando non funziona

• Dataset rifiutato: v3 richiesta
• Memoria esaurita durante l'addestramento
• La perdita diminuisce ma la policy non fa nulla
• La policy si blocca a metà movimento
• La policy funziona solo in una configurazione
• Job di addestramento bloccato in coda

Quanto costa un'esecuzione

Pi0.5 si trova nel livello costoso perché richiede una scheda da 80 GB, e i prezzi spot variano, quindi la cifra è un intervallo piuttosto che un prezzo. Per molte attività SO-100, addestra SmolVLA o ACT sul livello da 24 GB per prima cosa, conferma che l'attività sia apprendibile, quindi dedica ore A100 ad essa. Addestra la tua prima policy illustra quel ciclo più economico, e prezzi riporta i livelli attuali.

Prima di impegnare una serata: e presentano gli stessi numeri a confronto. L' contiene 85 modelli VLA con 332 risultati di benchmark, ciascuno collegato alla sua fonte, e il contesto sulla famiglia si trova in .