Cet article a été rédigé en collaboration avec Antoine Pirrone, Augustin Crampette, Matthieu Lapeyre, Coralie Deplanne, Anne-Charlotte Passanisi et Thomas Wolf.
TL;DR
Microduck est un robot bipède open-source abordable récemment publié par Pollen Robotics et Hugging Face. Et maintenant, vous pouvez entraîner Microduck à marcher avec Isaac Lab et Newton. Testez la politique, exportez-la en ONNX et déployez-la sur le vrai robot. Partagez-la sur le Hugging Face Hub ou validez-la pour une compétition dans la Microduck Arena, puis explorez des tâches plus avancées avec NVIDIA Isaac Lab.
Introduction
Une politique de marche entraînée en simulation doit également gérer le frottement, les délais et le jeu mécanique des servomoteurs d'un vrai robot.. NVIDIA Isaac Lab est un framework open-source pour entraîner des politiques sur des milliers de simulations parallélisées sur GPU. Avec Newton, la modélisation des actionneurs et la randomisation de domaine, les développeurs peuvent préparer des politiques pour du matériel réel. Microduck donne vie à ce flux de travail : entraîner une politique de marche en simulation, l'exporter en ONNX et la déployer sur un vrai robot bipède.
Ce tutoriel vous guide à travers l'entraînement et l'évaluation de Microduck avec Isaac Lab et Newton, puis l'exportation de la politique pour le déploiement. À partir de là, vous pouvez partager votre modèle sur le Hugging Face Hub, tester sa compatibilité et participer à la Microduck Arena, ou l'utiliser sur votre propre Microduck. La marche est le point de départ — avec des exemples liés pour vous aider à explorer davantage Isaac Lab 3.0.
1. Installer Isaac Lab et préparer l'entraînement de Microduck
Pour la partie simulation et entraînement, vous aurez besoin de :
Une station de travail Linux avec un GPU NVIDIA et un pilote pris en charge. Voir les requirements.
Git et uv.
Pour le déploiement, vous aurez également besoin de :
Un Microduck physique configuré.
Son logiciel robotique embarqué est installé et fonctionnel.
Une interface de contrôle prise en charge, comme une manette de jeu appariée.
Installation rapide
Sous Linux avec un GPU NVIDIA et un pilote pris en charge, installez uv (ignorez les deux premières lignes s'il est déjà disponible), clonez Isaac Lab et installez ses dépendances :
curl -LsSf https://astral.sh/uv/install.sh | sh
source "$HOME/.local/bin/env"
git clone --branch develop https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab
uv sync
Confirmez que les tâches et préréglages Microduck sont disponibles :
uv run isaaclab list_envs --keyword MicroDuck --show_presets
2. Comprendre l'environnement Microduck prêt à l'entraînement
Isaac Lab fournit déjà le modèle de robot de Microduck, la scène, les observations, les actions, les récompenses et la randomisation de domaine. Commencez par la tâche de marche sur terrain plat ; la variante rough ajoute des escaliers, des pentes et un terrain accidenté.
Figure 2. Environnements Microduck côte à côte : terrain plat (à gauche) et terrain accidenté (à droite).
La politique prend 61 valeurs d'observation et sort 14 positions d'articulations. Conservez l'ordre des observations, la normalisation et la mise à l'échelle des actions de manière cohérente lors de l'exportation et du déploiement. Voir la configuration de la tâche Microduck pour l'ensemble des observations, des récompenses et des paramètres de simulation.
3. Accélérer l'entraînement de la locomotion avec les environnements parallèles d'Isaac Lab
Isaac Lab accélère l'entraînement de la locomotion de Microduck en exécutant des environnements simulés en parallèle sur le GPU. Isaac Lab peut également exécuter un entraînement distribué sur plusieurs GPU, par exemple un entraînement avec 16 GPU pour accélérer l'entraînement et augmenter la robustesse. Dans cette configuration, nous pouvons atteindre jusqu'à 1,25 M de pas par seconde avec le terrain accidenté et le jeu de backlash activés.
Dans ce tutoriel, nous utilisons Newton avec le solveur MJWarp et des modèles d'actionneurs améliorés basés sur Newton (Better Actuator Models, BAM) pour modéliser la réponse des servomoteurs, ainsi que le préréglage de jeu mécanique (backlash) pour convertir les consignes de position en couples de servomoteur réalistes en modélisant le contrôleur du firmware, les limites électriques du moteur, le frottement et le délai. Pour permettre le transfert de la politique depuis la simulation, nous avons recours à la randomisation de domaine. Sur chaque canard, nous randomisons la masse/le centre de masse, le frottement au sol, l'inertie des articulations, les décalages des encodeurs, la tension/l'affaissement de la batterie et la latence des commandes. Nous varions également le terrain et appliquons des poussées ; ainsi que le jeu mécanique indépendamment pour chaque articulation afin de représenter une usure inégale.
Le jeu mécanique (backlash) est le jeu présent dans un réducteur : lorsqu'une articulation change de direction, la transmission peut bouger légèrement avant de s'engager. Modéliser cet effet et le faire varier entre les articulations pendant l'entraînement expose la politique aux différences qu'elle peut rencontrer sur le robot réel.
Exécutez cette commande pour démarrer l'entraînement :
uv run isaaclab train \
--rl_library rsl_rl \
--task IsaacContrib-Velocity-Rough-MicroDuck \
--num_envs 4096 \
presets=backlash
Nous avons utilisé le terrain accidenté pour le déploiement, mais vous pouvez aussi entraîner l'environnement en terrain plat avec cette commande :
uv run isaaclab train \
--rl_library rsl_rl \
--task IsaacContrib-Velocity-Flat-MicroDuck \
--num_envs 4096 \
presets=backlash
4. Évaluer la politique de marche du Microduck et l'exporter en ONNX
Pour déployer une politique de marche du Microduck sur le robot physique, exportez-la en ONNX après l'avoir évaluée en simulation. Le flux de travail de lecture RSL-RL d'Isaac Lab exporte automatiquement les fichiers TorchScript (policy.pt) et ONNX (policy.onnx). Utilisez policy.onnx avec le runtime embarqué du Microduck, en maintenant l'ordre des observations, la normalisation et la mise à l'échelle des actions cohérents avec l'entraînement.
Exécutez le dernier checkpoint dans le visualiseur Newton :
uv run isaaclab play \
--rl_library rsl_rl \
--task IsaacContrib-Velocity-Rough-MicroDuck \
--checkpoint latest \
--num_envs 16 \
--viz newton_gl \
presets=backlash
Remplacez latest par le chemin vers un checkpoint spécifique.
Figure 4. Des Microducks exécutent une politique de marche sur un terrain accidenté en simulation.
Exporter la politique pour le Microduck
Pour le déploiement, nous utiliserons la politique pour l'environnement en terrain accidenté. L'implémentation actuelle de la lecture RSL-RL exporte les fichiers TorchScript et ONNX dans un exported répertoire associé à la run sélectionnée :
exported/
├── policy.pt
└── policy.onnx
Le runtime embarqué du Microduck charge les politiques ONNX. Utilisez policy.onnx pour la passation au matériel. L'export automatique est implémenté dans le backend de lecture RSL-RL d'Isaac Lab.
5. Partager les politiques sur Hugging Face et les évaluer dans Microduck Arena
Une fois la politique policy.onnx exportée, vous pouvez :
La comparer dans Microduck Arena, un Hugging Face Space permettant de tester des politiques compatibles sur des défis partagés et de comparer les résultats des classements. Arena accepte les modèles avec 61 valeurs d'observation, 14 valeurs d'action et une taille maximale de 64 MiB. Suivez le guide de soumission pour vérifier la compatibilité et participer à un défi.
L'exécuter sur le vrai Microduck. Après avoir vérifié l'interface d'observation et d'action de la section 4, utilisez le fichier ONNX avec le runtime embarqué du robot ; la section 6 couvre le transfert vers le matériel.
La partager sur le Hugging Face Hub. Publiez votre politique afin que d'autres puissent la découvrir et la télécharger. Nous recommandons d'ajouter une courte fiche de modèle expliquant comment l'utiliser. Vous pouvez également inclure la configuration d'entraînement pour aider les autres à reproduire vos résultats.
6. Déployer la politique de locomotion ONNX sur un vrai Microduck
Après avoir validé la politique en simulation et vérifié son interface (section 4), déployez policy.onnx sur un Microduck configuré :
- Copiez la politique depuis votre poste de travail, en remplaçant ROBOT_HOST par le nom d'hôte ou l'adresse IP du robot :
scp exported/policy.onnx microduck@ROBOT_HOST:/home/microduck/my_walking.onnx
- Connectez-vous au robot et inspectez ses politiques actuelles :
ssh microduck@ROBOT_HOST
robotctl policy list
- Supportez le robot sur son support, puis chargez la politique de marche. S'il marche déjà, le chargement le ramène à sa pose d'origine et reprend le mouvement.
sudo robotctl policy load walk /home/microduck/my_walking.onnx
- Utilisez les commandes documentées pour tester la position debout, la marche lente, le virage et l'arrêt. Surveillez son état ; restaurez la politique de marche par défaut si nécessaire :
robotctl monitor
sudo robotctl policy reset walk
Suivez le guide de chargement des politiques de Microduck pour la configuration à l'exécution et le comportement. La figure 5 démontre la robustesse de la politique déployée face aux chutes : Microduck retrouve son équilibre et reprend la marche après avoir été renversé.
Figure 5. Le vrai Microduck marchant avec la politique de locomotion entraînée dans Isaac Lab.
7. Étendre l'entraînement de Microduck aux terrains accidentés et aux tâches de perception avec Isaac Lab
Isaac Lab 3.0 permet l'apprentissage robotique parallèle sur GPU dans les domaines de la locomotion, de la manipulation dextre et des tâches basées sur la vision, avec des environnements extensibles et des backends de physique et de rendu configurables. Explorez ces exemples et outils :
Locomotion plus complexe: Adaptez la tâche terrain accidenté de Microduck aux escaliers, aux pentes et aux sols irréguliers, avec un curriculum qui augmente la difficulté du terrain.
Tâches de perception et de navigation : Étendez la politique de marche de Microduck avec des observations de profondeur provenant de la caméra frontale et de l'état du robot afin d'explorer des tâches basées sur la perception en simulation. Le GIF ci-dessous montre la traversée d'une rampe. Explorez les observations basées sur la caméra dans les exemples Kuka–Allegro pour la manipulation avec vision.
Manipulation dextre: Essayez les tâches de levage et de réorientation Kuka–Allegro pour entraîner un bras et une main multi-doigts à manipuler des objets.
Environnements personnalisés: Utilisez le générateur de projet pour construire votre propre tâche, puis ajoutez des actifs SimReady (prêts pour la simulation) depuis la SimReady Central Library, et adaptez les observations et les récompenses à de nouveaux défis.
Figure 7. L'entraînement parallèle dans NVIDIA Isaac Lab permet à des Microducks simulés de s'exercer à traverser différentes rampes et plateformes, tout en apprenant à maintenir l'équilibre et à éviter les chutes
Figure 8. Tâche de perception de Microduck en simulation, avec une vue externe au-dessus et des vues RVB, de profondeur et de segmentation en dessous.
Construisez votre prochaine politique de marche
Commencez avec la tâche Microduck dans Isaac Lab, entraînez votre première politique de marche et partagez le modèle ONNX exporté sur le Hugging Face Hub. Validez-le dans Microduck Arena, participez à un défi et voyez comment votre politique se compare. Ensuite, construisez sur ce que vous avez appris — essayez un terrain plus accidenté, ajoutez la perception ou créez votre propre tâche.
Ressources
Page d'accueil de Microduck (commande, démarrage rapide, installation)
Remerciements
Ce flux de travail s'appuie sur le matériel et le logiciel Microduck de Pollen Robotics, le projet original de renforcement apprentissage Microduck, travail de modélisation de l'actionneur BAM, ainsi que sur les intégrations Isaac Lab et Newton.