Comment entraîner Pi0.5 sur vos propres données de robot

Pi0.5 est le modèle à privilégier lorsqu'une politique doit fonctionner dans une pièce qu'elle n'a jamais vue. C'est aussi le plus délicat des cinq politiques entraînables ici à affiner à la main : le dépôt amont est d'abord JAX, le port LeRobot a déplacé le déploiement hors de lerobot-record en 0.6.0 et a rendu l'installation de base trop petite pour l'entraînement, et un affinage complet ne tient pas sur une 4090. Ci-dessous : ce que le flow matching coûte à l'inférence, les deux chemins de commande, et le nombre de 485 ms qui décide si le résultat est utilisable.

Ce qu'est réellement Pi0.5

Physical Intelligence a publié pi0 en octobre 2024 : un modèle vision-langage-action de type flow matching basé sur un VLM pré-entraîné : PaliGemma avec 3 milliards de paramètres plus un expert d'action de 300 millions de paramètres initialisé à partir de zéro, soit 3,3 milliards au total. L'article rapporte un pré-entraînement sur plus de 10 000 heures de données robotiques à travers 7 configurations de robots et 68 tâches. Plus d'informations dans l'article sur pi0.

Pi0.5 (arXiv 2504.16054, 22 avril 2025) conserve cette architecture et modifie le régime d'entraînement : données web, détection d'objets, instructions verbales d'humains coachant le robot, étiquettes de sous-tâches, données inter-incarnations provenant de robots dans de nombreux foyers. Le résultat est un robot nettoyant des cuisines dans des maisons qui ne faisaient pas partie de l'ensemble d'entraînement. Le README d'openpi ajoute un détail que le titre n'indique pas : le pi0.5 publié a été entraîné avec une isolation des connaissances (arXiv 2505.23705).

Ce que le "flow matching" change dans l'entraînement et l'inférence

Une politique que vous pouvez entraîner sur un SO-100 régresse soit directement les actions (ACT) ou les tokenise et les décode de manière autorégressive (pi0-FAST). Le flow matching ne fait ni l'un ni l'autre : il apprend un champ vectoriel qui transporte le bruit vers un morceau d'action, puis l'intègre. L'article pi0 utilise 10 étapes d'intégration avec un pas de 0,1 ; la configuration pi05 de LeRobot utilise le même `num_inference_steps: int = 10`.

• Entraînement : la perte régresse un morceau d'action bruité. Pas de tokenizer à ajuster, pas de discrétisation de vos angles articulaires.
• Inférence : un morceau coûte dix passages avant à travers l'expert d'action. C'est structurel, pas un problème d'ajustement.
• Sortie : actions continues de dimension 32, complétées en interne, perte calculée sur les dimensions de votre robot. Un bras à 6-DoF plus pince utilise 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

Le backbone PaliGemma, et la porte devant lui

PaliGemma (arXiv 2407.07726) est un encodeur de vision SigLIP-So400m basé sur un modèle de langage Gemma-2B, d'environ 3 milliards de paramètres. Pi0.5 hérite de son tokenizer, et ce tokenizer se trouve dans un dépôt à accès restreint. C'est la manière la plus courante pour qu'une première exécution échoue, avant la première étape d'entraînement.

Avant de commencer : format du jeu de données, épisodes, matériel

Pi0.5 dans LeRobot lit un jeu de données LeRobot au format v3.0, qui est apparu avec lerobot 0.4.0 en octobre 2025 : plusieurs épisodes par fichier Parquet et MP4 au lieu d'un fichier par épisode, avec des limites dans meta/episodes/ plutôt que dans les noms de fichiers. Enregistrez avec le client de bureau ou suivez enregistrez votre premier jeu de données et vous l'aurez.

# 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 plateforme requiert au moins 50 épisodes pour Pi0.5, le même seuil que pour GR00T et ACT. Le pré-entraînement fait le plus gros du travail, donc 50 épisodes propres valent mieux que 200 bâclés. Nouveau dans ce domaine ? Commencez par le guide de collecte de données.

Voie A : affiner avec le dépôt openpi

L'implémentation de référence : JAX d'abord, testée uniquement sur Ubuntu 22.04, pilotée par des objets de configuration plutôt que par des drapeaux. Un chemin PyTorch est arrivé en septembre 2025, validé sur LIBERO. Trois étapes : convertir vos données, définir une configuration, entraîner et servir.

1. 1
   Cloner et installer

   openpi utilise uv. GIT_LFS_SKIP_SMUDGE permet à LeRobot d'être une dépendance sans les objets 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
   Convertir vos données en un jeu de données LeRobot

   L'amont fournit des convertisseurs pour LIBERO et DROID et s'attend à ce que vous en adaptiez un. Le travail consiste à mapper les clés.

   bash

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

3. 3
   Ajouter une configuration d'entraînement

   Les configurations sont des entrées TrainConfig dans src/openpi/training/config.py. Celle-ci adapte pi05_droid_finetune, avec le chargeur de poids pointant vers 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
   Calculer les statistiques de normalisation

   S'exécute par rapport au nom de la configuration, pas au jeu de données. Le sauter est la première erreur classique ici.

   bash

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

5. 5
   Entraîner

   La variable permet à JAX d'utiliser 90 % de la mémoire GPU au lieu des 75 % par défaut. Sur une carte de 80 Go, cela détermine si l'exécution survit.

   bash

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

6. 6
   Servir

   Le serveur écoute sur le port 8000 et répond aux requêtes d'observation ; votre environnement d'exécution robotique est le client.

   bash

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

Route B : affiner avec lerobot pi05

Le port LeRobot encapsule les mêmes poids dans l'interface de ligne de commande que vous utilisez déjà pour ACT et SmolVLA. Tout ce qui suit a été vérifié par rapport à lerobot 0.6.1, la version depuis le 3 août 2026, et la documentation de pi05 du 23 août 2026. Les versions sont importantes ici : les jeux de données v3.0 sont arrivés avec la version 0.4.0 en octobre 2025, le blog 0.5.0 du 9 mars 2026 présente pi0-FAST et le Real-Time Chunking, et la version 0.6.0 du 6 juillet 2026 a allégé le package de base et déplacé le déploiement vers lerobot-rollout.

Une chose n'a pas changé : lerobot-train et lerobot-record étaient déjà des points d'entrée dans la version 0.3.2, en août 2025. Un tutoriel qui appelle encore python -m lerobot.scripts.train est antérieur à une année de changements et mérite d'être mis en doute sur le reste également.

1. 1
   Installer avec les bons extras

   Depuis la version 0.6.0, l'installation de base ne contient que les dépendances ML essentielles, et l'extra pi n'ajoute aucun code de jeu de données ou d'entraînement. Une mise au point nécessite donc également l'extra d'entraînement. Les anciennes commandes en une ligne échouent ici au moment de l'importation.

   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
   S'authentifier

   Acceptez la licence paligemma-3b-pt-224 dans un navigateur, puis connectez-vous sur la machine d'entraînement.

   bash

   hf auth login

3. 3
   Ajouter des statistiques de quantiles

   Pi0.5 normalise STATE et ACTION avec des quantiles, donc meta/stats.json a besoin de q01 et q99. Les anciens jeux de données ne contiennent que 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
   Affiner à partir de lerobot/pi05_base

   Définissez la taille du lot en fonction de ce que votre carte peut supporter ; la documentation utilise 64 sur LIBERO avec 80 Go. Passez bfloat16 explicitement, la valeur par défaut de la configuration est 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
   L'exécuter sur le bras

   Dans la version 0.6.x, c'est lerobot-rollout : lerobot-record refuse une politique et rejette les noms de jeux de données eval_. Base pilote le bras, sentry enregistre le déploiement.

   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

Trois ensembles de valeurs par défaut, et lesquels atteignent l'entraîneur

TrainConfig d'openpi est la référence, PI05Config de LeRobot est ce que lerobot-train utilise par défaut, et le formulaire ici envoie un troisième ensemble. La surprise est le taux d'apprentissage : les deux valeurs par défaut en amont culminent à 2.5e-5, tandis que la configuration pi05_libero d'openpi et cette plateforme le portent à 5e-5.

Le portage est-il fidèle ? L'équipe LeRobot a affiné le modèle de base LIBERO sur 6k étapes supplémentaires et a comparé les résultats avec les chiffres de référence d'openpi sur quatre suites : 97.5 pour cent en moyenne contre 96.85, en avance sur Libero 10, en retard sur Spatial. Le choix de l'implémentation est un choix d'outillage, pas de qualité.

La réalité des 485 ms, et où cela cesse d'être utilisable

Cela détermine votre projet, donc cela précède le tableau des coûts. La par étape d'action mesurée ici pour Pi0.5 est de 485 ms. Comparé aux quatre autres :

L'amont a une réponse, et la moitié est déjà dans la version que vous pouvez installer. Le 'Real-Time Chunking' génère le segment suivant pendant que le bras exécute encore le segment actuel, puis guide les étapes qui se chevauchent du nouveau segment pour qu'elles restent proches de la partie déjà exécutée, afin que le bras ne cale pas ou ne saccade pas à la jonction. La forme d'inférence a été livrée dans le changelog 0.4.2 pour Pi0, Pi0.5 et SmolVLA et est un flag de déploiement, pas un réentraînement :

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

Cela ne rend pas le modèle plus rapide. Cela masque le délai : les 485 ms sont toujours dépensées, mais hors du chemin critique, de sorte que la file d'attente ne se vide pas entre les segments. La variante au moment de l'entraînement, issue d'arXiv 2512.05964, va plus loin : le modèle apprend à se conditionner sur un préfixe d'action propre, de sorte qu'à l'inférence, le chevauchement est 'hard-inpainted' avec des pas de temps de flux par action au lieu d'être guidé, et le passage arrière de guidage disparaît. Pendant l'entraînement, il échantillonne une longueur de préfixe par exemple et calcule la perte de flux sur le suffixe restant. Ce flag n'est disponible que sur 'main', pas dans la version 0.6.1, et le délai pour lequel vous entraînez doit rester inférieur à chunk_size.

Deux façons d'obtenir 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

Quand cela ne fonctionne pas

• Jeu de données rejeté : v3 requise
• Mémoire insuffisante pendant l'entraînement
• La perte diminue mais la politique ne fait rien
• La politique se fige en plein mouvement
• La politique ne fonctionne que dans une seule configuration
• Tâche d'entraînement bloquée en file d'attente

Ce que coûte une exécution

Pi0.5 se situe dans la catégorie coûteuse car il nécessite une carte de 80 Go, et les prix spot varient, donc le chiffre est une fourchette plutôt qu'un prix. Pour de nombreuses tâches SO-100, entraînez SmolVLA ou ACT sur la catégorie 24 Go d'abord, confirmez que la tâche est bien apprenable, puis consacrez-y des heures A100. Entraînez votre première politique parcourt cette boucle moins chère, et la tarification contient les catégories actuelles.

Avant de vous engager pour une soirée : GR00T N1.7 contre Pi0.5 et Pi0.5 contre SmolVLA présentent les mêmes chiffres côte à côte. L'Arène contient 85 modèles VLA avec 332 résultats de benchmark, chacun lié à sa source, et des informations de fond sur la famille se trouvent dans notre aperçu des VLA.