Politique π₀.₅ (Pi05)

π₀.₅ est un modèle Vision-Language-Action avec généralisation en monde ouvert, de Physical Intelligence. L'implémentation LeRobot est adaptée de leur dépôt open source OpenPI.

Aperçu du modèle

π₀.₅ représente une évolution significative par rapport à π₀, développé par Physical Intelligence pour relever un défi majeur en robotique : la généralisation en monde ouvert. Bien que les robots puissent effectuer des tâches impressionnantes dans des environnements contrôlés, π₀.₅ est conçu pour se généraliser à des environnements et des situations entièrement nouveaux, jamais vus lors de l’entraînement.

Le défi de la généralisation

Comme l’explique Physical Intelligence, le défi fondamental ne réside pas dans l’exécution de tâches d’agilité ou de dextérité, mais dans la généralisation, c’est-à-dire la capacité à exécuter correctement des tâches dans de nouveaux environnements avec de nouveaux objets. Pensez à un robot qui nettoie différentes maisons : chaque maison contient des objets différents, placés à des endroits différents. La généralisation doit se produire à plusieurs niveaux :

• Niveau physique : Comprendre comment saisir une cuillère (par le manche) ou une assiette (par le bord), même avec des objets inconnus dans des environnements encombrés
• Niveau sémantique : Comprendre la sémantique de la tâche, où placer les vêtements et les chaussures (dans le panier à linge, pas sur le lit) et quels outils sont appropriés pour nettoyer les taches
• Niveau environnemental : s'adapter à des environnements réels « complexes » tels que les foyers, les supermarchés, les bureaux et les hôpitaux

Co-entraînement sur des données hétérogènes

L'innovation majeure de π₀.₅ est le co-entraînement sur des sources de données hétérogènes. Le modèle apprend à partir de :

1. Données Web multimodales : légende d'images, question-réponse visuelle, détection d'objets
2. Instructions verbales : Des humains qui guident des robots à travers des tâches complexes, étape par étape
3. Commandes de sous-tâches : Étiquettes de comportement sémantique de haut niveau (par exemple, « prendre l'oreiller » pour un lit défait)
4. Données robotiques multi-embodiments : Données issues de différentes plateformes robotiques aux capacités variées
5. Données multi-environnements : Robots statiques déployés dans de nombreuses maisons différentes
6. Données de manipulation mobile : ~400 heures de démonstrations de robots mobiles

Ce mélange d'entraînement diversifié crée un « curriculum » qui permet la généralisation simultanée aux niveaux physique, visuel et sémantique.

Prérequis d'installation

1. Installez LeRobot en suivant notre Guide d'installation.

2. Installez les dépendances de Pi0.5 en exécutant :

   Copié

   pip install -e ".[pi]"

   Si vous avez installé LeRobot depuis PyPI :

   Copié

   pip install 'lerobot[pi]'

Utilisation

Pour utiliser π₀.₅ dans votre configuration LeRobot, spécifiez le type de politique comme suit :

policy.type=pi05

Entraînement

Démarrage rapide sur LIBERO

Effectuez le fine-tuning du modèle de base LIBERO sur lerobot/libero, une copie encodée en vidéo d’environ 1,9 Go des démonstrations à l’origine des résultats ci-dessous.

Il contient les clés que π₀.₅ lit, qui sont également celles que l’environnement LIBERO génère lors de l’évaluation :

Aucun --rename_map n'est nécessaire ici — les clés correspondent déjà ; consultez Rename Map and Empty Cameras si les vôtres diffèrent.

π₀.₅ uses the gated [google/paligemma-3b-pt-224](https://huggingface.co/google/paligemma-3b-pt-224) tokenizer — accept its license on the Hub and log in with `hf auth login` before training.

Dimensionné pour un GPU 80 Go unique :

lerobot-train \
    --dataset.repo_id=lerobot/libero \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_libero_base \
    --policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}' \
    --policy.n_action_steps=10 \
    --policy.empty_cameras=1 \
    --policy.freeze_vision_encoder=false \
    --policy.train_expert_only=false \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --policy.push_to_hub=false \
    --output_dir=./outputs/pi05_libero \
    --job_name=pi05_libero \
    --batch_size=64 \
    --num_workers=8 \
    --steps=30000 \
    --save_freq=5000 \
    --seed=1000

Normalisation par moyenne/écart-type, et non la valeur par défaut par quantile de π₀.₅ — correspondant à pi05_libero_finetuned_v044, le point de contrôle sur lequel les résultats ci-dessous ont été mesurés.

--policy.n_action_steps=10 et --policy.empty_cameras=1 sont explicites car --policy.pretrained_path charge uniquement les poids — lerobot/pi05_libero_base stocke les deux, et ils retomberaient sinon sur 50 et 0 (voir Chargement d'un point de contrôle).

Évaluez ensuite un point de contrôle avec lerobot-eval et comparez-le aux taux de réussite de référence — voir LIBERO.

Statistiques de quantiles

π₀.₅ normalise STATE et ACTION à l'aide de quantiles, votre meta/stats.json doit donc contenir q01 et q99. Les anciens jeux de données ne contiennent que min/max/mean/std et échouent dès le premier lot :

ValueError: QUANTILES normalization mode requires q01 and q99 stats

Les recalculer :

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

Le résultat est enregistré dans $HF_LEROBOT_HOME/your_dataset, et non dans le cache lu par --dataset.repo_id — entraînez donc le modèle avec --dataset.root=$HF_LEROBOT_HOME/your_dataset, ou ajoutez --push_to_hub true ci-dessus.

Ou conservez le jeu de données tel quel et passez --policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}'.

Enregistrement, reprise et fusion des quantiles agrégés à partir des résumés par épisode, afin que meta/stats.json contienne une enveloppe conservatrice (min pour q <= 50, max pour q > 50) plutôt que des quantiles sur l'ensemble du jeu de données. Pour estimer ces derniers, parcourez chaque épisode avec un histogramme incrémental :

python src/lerobot/scripts/augment_dataset_quantile_stats.py \
    --repo-id=your_dataset \
    --overwrite \
    --skip-images

--skip-images conserve les statistiques d’images existantes et évite le téléchargement ou le décodage des données vidéo lorsque seuls STATE/ACTION doivent être recalculés, et --root lit un jeu de données local au lieu du Hub. Ces valeurs sont des estimations par histogramme, sujettes à des erreurs de discrétisation et de rebinning, elles peuvent donc différer des valeurs conservatrices — ce qui modifie les cibles normalisées de π₀.₅ et, par conséquent, l’échelle de sa perte. Les statistiques déjà enregistrées dans un point de contrôle existant ne sont pas affectées.

Exemple de commande d'entraînement

Le même finetune avec le VLM figé : moins de mémoire, au prix d’un certain taux de réussite. Remplacez --dataset.repo_id par votre propre jeu de données.

lerobot-train \
    --dataset.repo_id=lerobot/libero \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_libero_base \
    --policy.normalization_mapping='{"ACTION": "MEAN_STD", "STATE": "MEAN_STD", "VISUAL": "IDENTITY"}' \
    --policy.n_action_steps=10 \
    --policy.empty_cameras=1 \
    --policy.freeze_vision_encoder=true \
    --policy.train_expert_only=true \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --policy.push_to_hub=false \
    --output_dir=./outputs/pi05_libero_expert \
    --job_name=pi05_libero_expert \
    --batch_size=64 \
    --num_workers=8 \
    --steps=30000 \
    --save_freq=5000 \
    --seed=1000

Paramètres d'entraînement clés

• --policy.compile_model=true : Active la compilation du modèle pour un entraînement plus rapide
• --policy.gradient_checkpointing=true : réduit considérablement l'utilisation de la mémoire pendant l'entraînement
• --policy.dtype=bfloat16 : Utiliser l'entraînement en précision mixte pour l'efficacité
• --batch_size=64 : Taille du lot pour l'entraînement, à adapter en fonction de la mémoire de votre GPU
• --policy.pretrained_path=lerobot/pi05_base: Le modèle de base π₀.₅ que vous souhaitez affiner. Les options sont :
  • lerobot/pi05_base
  • lerobot/pi05_libero_base (entraîné spécifiquement sur le jeu de données Libero)
• --policy.optimizer_fused=true : Utilise AdamW fusionné pour des étapes d’optimiseur plus rapides ; ce drapeau est ignoré lors de la reprise d’une exécution

RTC optionnel lors de l'entraînement

Pi05 peut apprendre de manière optionnelle un conditionnement par préfixe d'action pour un Real-Time Chunking efficace, en suivant Training-Time Action Conditioning for Efficient Real-Time Chunking. Définissez policy.rtc_training_max_delay sur le délai d'inférence maximal attendu en pas de contrôleur :

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.dtype=bfloat16 \
    --policy.device=cuda \
    --batch_size=8 \
    --steps=30000 \
    --output_dir=outputs/pi05_rtc \
    --job_name=pi05_rtc

La valeur par défaut est 0, ce qui désactive le RTC pendant l'entraînement et laisse l'objectif standard de Pi05 inchangé. Le délai configuré doit être inférieur à chunk_size. Pendant l'entraînement, Pi05 échantillonne une longueur de préfixe propre indépendamment pour chaque exemple et calcule la perte de flux uniquement sur le suffixe restant.

Utilisez explicitement le checkpoint résultant avec le RTC entraîné :

lerobot-rollout \
    --strategy.type=base \
    --policy.path=outputs/pi05_rtc/checkpoints/last/pretrained_model \
    --inference.type=rtc \
    --inference.rtc.mode=trained \
    --inference.rtc.execution_horizon=10 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --task="pick up the cube" \
    --fps=50 \
    --device=cuda

Définissez inference.rtc.execution_horizon entre rtc_training_max_delay et chunk_size - rtc_training_max_delay du checkpoint, et inference.queue_threshold à au moins rtc_training_max_delay. Une pointe de latence unique dépassant la plage entraînée entraîne l’abandon de ce chunk et une nouvelle tentative ; le rollout s’arrête avec une erreur explicite uniquement si le délai reste hors de la plage. Le mode par défaut --inference.rtc.mode=guided reste disponible pour les checkpoints ordinaires.

Chargement d'un point de contrôle

Les deux formes ne sont pas interchangeables :

Utilisez --rename_map avec l’une ou l’autre forme de chargement lorsque les noms des fonctionnalités du jeu de données brut diffèrent des noms des fonctionnalités de la politique. Par exemple, la commande de fine-tuning de RoboMME associe ses colonnes brutes image, wrist_image, state et actions tout en initialisant les poids avec --policy.pretrained_path.

Explication des paramètres d'entraînement

💡 Astuce : Définir train_expert_only=true fige le VLM et entraîne uniquement l'expert d'action et les projections, permettant un affinement avec une consommation mémoire réduite.

Mémoire d'observation à court terme (MEM)

Pi05 peut éventuellement utiliser un contexte visuel et proprioceptif à court horizon basé sur MEM. Les deux chemins sont désactivés par défaut, de sorte que les points de contrôle et les commandes d'entraînement existants conservent le comportement Pi05 à image unique.

Cette implémentation ne couvre que la mémoire à court terme de MEM — l’encodeur vidéo de la section III-C et la projection proprioceptive de la section III-D. La mémoire à long terme linguistique de MEM (section III-B), dans laquelle une politique de haut niveau prédit la sous-tâche suivante ainsi qu’un résumé en langage naturel compressé de ce qui s’est passé jusqu’à présent, n’est pas implémentée. Dans les ablations de l’article, la mémoire vidéo seule ne récupère qu’une partie de la progression sur les tâches de MEM complet pour les tâches à long terme.

Introduire la mémoire lors de l’ajustement fin à partir d’un point de contrôle pré-entraîné sans celle-ci correspond également à l’ablation plus faible MEM-Posttrain-Only du papier. Les résultats principaux de MEM proviennent de la pré-entraînement de l’encodeur vidéo sur un mélange diversifié de vidéos robotiques et non robotiques, ce qu’aucun point de contrôle Pi05 public ne fournit actuellement.

Activez-le lors de l’ajustement fin avec :

lerobot-train \
    --dataset.repo_id=your_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.use_visual_memory=true \
    --policy.memory_frames=6 \
    --policy.memory_stride=30 \
    --policy.memory_temporal_attention_every=4 \
    ...

memory_frames inclut l’observation actuelle. memory_stride est mesuré en images du jeu de données, et non en secondes, il faut donc l’adapter à la fps de votre jeu de données : MEM pré-entraîne sur six observations espacées d’une seconde, ce qui correspond à memory_stride=30 pour un jeu de données à 30 fps (la valeur par défaut) mais à memory_stride=10 pour un jeu de données à 10 fps tel que lerobot/robomme.

Toutes les quatre couches de SigLIP remplacent leur attention par l'attention espace-temps composée de MEM : une attention temporelle causale entre les jetons de patch correspondants, composée avec l'attention spatiale standard et réutilisant les projections pré-entraînées, de sorte qu'aucun paramètre apprenable n'est ajouté à la tour de vision. Les jetons des images précédentes sont supprimés une fois que la dernière couche de ce type a été exécutée, ce qui maintient la longueur du préfixe langage/action en aval inchangée.

L’historique indisponible au début d’un épisode est complété par des valeurs de bourrage et masqué. Lors de l’inférence, Pi05 maintient en interne le même historique d’images à pas et le réinitialise à chaque fois que la politique est réinitialisée.

La proprioception historique est une option indépendante :

--policy.use_proprioceptive_memory=true

Lorsqu’activé, un jeton d’état continu projeté est ajouté pour chaque frame conservée, et l’état discrétisé est retiré du prompt texte afin que l’état soit représenté exactement une fois (section III-D de MEM). Cela modifie le format du prompt, il convient donc de l’activer dès le début de l’entraînement plutôt qu’en cours de route. La mémoire visuelle et la mémoire proprioceptive utilisent les mêmes paramètres memory_frames et memory_stride, mais chaque chemin peut être activé indépendamment. Entraînez ou affinez le modèle avec les options de mémoire sélectionnées ; les activer uniquement lors de l’inférence ne confère pas au checkpoint mono-frame un comportement de mémoire appris.

Sous PEFT, proprio_history_proj est entraîné et enregistré en totalité via modules_to_save, car il ne possède pas de poids préentraînés à adapter.

À l'inférence, MEM conserve une file d'historique par lot et suppose que chaque ligne du lot partage les mêmes limites d'épisode. lerobot-eval satisfait cette condition en appelant policy.reset() avant chaque déroulement par lot et avant la réinitialisation de l'environnement vectoriel. La réinitialisation automatique indépendante des lignes dans un lot vectoriel asynchrone n'est pas prise en charge ; démarrez un nouveau déroulement afin que les files de politique et d'action complètes soient réinitialisées ensemble.

Actions relatives

Par défaut, π₀.₅ prédit des actions absolues. Vous pouvez activer les actions relatives afin que le modèle prédise des décalages par rapport à l'état actuel du robot. Cela peut améliorer la stabilité de l'entraînement pour certaines configurations.

Pour utiliser des actions relatives, recomputez d'abord les statistiques de votre jeu de données dans l'espace relatif via l'interface en ligne de commande :

lerobot-edit-dataset \
    --repo_id your_dataset \
    --new_repo_id your_dataset \
    --operation.type recompute_stats \
    --operation.overwrite true \
    --operation.relative_action true \
    --operation.chunk_size 50 \
    --operation.relative_exclude_joints "['gripper']" \
    --push_to_hub true

Ou de manière équivalente en Python :

from lerobot.datasets import LeRobotDataset, recompute_stats

dataset = LeRobotDataset("your_dataset")
recompute_stats(dataset, relative_action=True, chunk_size=50, relative_exclude_joints=["gripper"])
dataset.push_to_hub()

chunk_size doit correspondre au chunk_size de votre politique (50 par défaut pour π₀.₅). relative_exclude_joints énumère les noms d’articulations qui doivent rester dans l’espace absolu (par exemple, les commandes de pince). Utilisez --push_to_hub true pour téléverser les statistiques mises à jour sur le Hub.

Ensuite, entraînez avec les actions relatives activées :

lerobot-train \
    --dataset.repo_id=your_dataset \
    --policy.type=pi05 \
    --policy.use_relative_actions=true \
    --policy.relative_exclude_joints='["gripper"]' \
    ...

Résultats de performance

Résultats du benchmark Libero

π₀.₅ a démontré de solides performances sur la suite de benchmarks Libero. Pour comparer et tester son implémentation LeRobot, nous avons effectué un fine-tuning du modèle de base libero pendant 6 000 étapes supplémentaires sur le jeu de données Libero, puis comparé les résultats aux résultats de référence OpenPI.

Ces résultats démontrent les fortes capacités de généralisation de π₀.₅ à travers diverses tâches de manipulation robotique. Pour reproduire ces résultats, vous pouvez suivre les instructions de la section Libero.

Licence

Ce modèle est soumis à la licence Apache 2.0, conformément au dépôt OpenPI d'origine.