π₀ (Pi0)

π₀ est un modèle Vision-Language-Action pour le contrôle général de robots, 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 percée dans le domaine de la robotique en tant que premier modèle de fondation généraliste pour robots, développé par Physical Intelligence. Contrairement aux programmes robotiques traditionnels, qui sont des spécialistes étroits programmés pour des mouvements répétitifs, π₀ est conçu comme une politique généraliste capable de comprendre les entrées visuelles, d’interpréter des instructions en langage naturel et de contrôler une variété de robots différents sur des tâches diverses.

La vision de l'intelligence physique

Comme l’explique Physical Intelligence, bien que l’IA ait connu un succès remarquable dans les domaines numériques, allant du jeu d’échecs à la découverte de médicaments, l’intelligence humaine surpasse encore de loin l’IA dans le monde physique. Pour paraphraser le paradoxe de Moravec, gagner une partie d’échecs constitue un problème « facile » pour l’IA, mais plier une chemise ou ranger une table exige de résoudre certains des problèmes d’ingénierie les plus difficiles jamais imaginés. π₀ représente une première étape vers le développement d’une intelligence physique artificielle permettant aux utilisateurs de simplement demander à des robots d’exécuter n’importe quelle tâche qu’ils souhaitent, tout comme ils peuvent le faire avec les grands modèles de langage.

Architecture et approche

π₀ combine plusieurs innovations clés :

• Flow Matching : Utilise une méthode novatrice pour enrichir les VLM pré-entraînés avec des sorties d’actions continues via le flow matching (une variante des modèles de diffusion)
• Entraînement inter-embodiments : Entraîné sur des données provenant de 8 plateformes robotiques distinctes, notamment UR5e, Bimanual UR5e, Franka, Bimanual Trossen, Bimanual ARX, Mobile Trossen et Mobile Fibocom
• Pré-entraînement à l'échelle d'Internet : Hérite des connaissances sémantiques d'un modèle Vision-Language pré-entraîné de 3 milliards de paramètres
• Contrôle haute fréquence : Émet des commandes moteur à une fréquence allant jusqu'à 50 Hz pour une manipulation dextre en temps réel

Prérequis d'installation

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

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

   Copié

   pip install -e ".[pi]"

Données d'entraînement et fonctionnalités

π₀ est entraîné sur le plus grand jeu de données d'interaction robotique à ce jour, combinant trois sources de données clés :

1. Pré-entraînement à l'échelle d'Internet : Données vision-langage issues du web pour la compréhension sémantique
2. Jeu de données X-Embodiment : jeux de données open source de manipulation robotique
3. Physical Intelligence Dataset : Jeu de données volumineux et diversifié de tâches dextères sur 8 robots distincts

Utilisation

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

policy.type=pi0

Entraînement

Pour l’entraînement de π₀, vous pouvez utiliser le script d’entraînement standard de LeRobot avec la configuration appropriée :

lerobot-train \
    --dataset.repo_id=your_dataset \
    --policy.type=pi0 \
    --output_dir=./outputs/pi0_training \
    --job_name=pi0_training \
    --policy.pretrained_path=lerobot/pi0_base \
    --policy.repo_id=your_repo_id \
    --policy.compile_model=true \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --policy.freeze_vision_encoder=false \
    --policy.train_expert_only=false \
    --steps=3000 \
    --policy.device=cuda \
    --batch_size=32

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=32 : Taille du lot pour l'entraînement, à adapter en fonction de la mémoire de votre GPU
• --policy.pretrained_path=lerobot/pi0_base: Le modèle de base π₀ que vous souhaitez affiner. Les options sont :
  • lerobot/pi0_base
  • lerobot/pi0_libero (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

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.

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=pi0 \
    --policy.use_relative_actions=true \
    --policy.relative_exclude_joints='["gripper"]' \
    ...

Licence

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