Ce que signifie l’apprentissage par renforcement pour un petit bipède
L’apprentissage par renforcement (RL, pour reinforcement learning) entraîne une politique de contrôle par essais et erreurs. La politique est un petit réseau de neurones qui lit les positions et vitesses des articulations ainsi que l’orientation du corps du robot, et qui fournit une consigne à chaque servo. Une fonction de récompense note chaque pas (suivre la vitesse demandée, rester debout, ne pas taper des pieds) et l’algorithme d’entraînement ajuste le réseau pour obtenir davantage de récompense. Pour les robots à pattes, tout se passe dans un simulateur physique, où des milliers de copies du robot peuvent tomber en même temps sans aucun risque.
Microduck est un bon robot pour apprendre l’apprentissage par renforcement, car toute la recette est ouverte. Pollen Robotics publie le robot et ses environnements d’entraînement RL, et Luwu Dynamics publie une version dérivée pour la variante Arduino UNO Q. Les deux entraînent la marche, le relevé, l’assise et des figures avec PPO, puis exportent la politique en ONNX pour que le robot puisse l’exécuter.
Le RL n’est pas l’apprentissage par imitation de notre guide LeRobot. Là-bas, une personne montre la tâche et le réseau copie les démonstrations. Ici, personne ne montre comment marcher : la récompense définit ce qu’est une bonne marche, et le simulateur fournit l’entraînement.
Nous avons rédigé ce guide à partir de la documentation publiée par les deux projets et de nos propres notes techniques. Nous n’avons pas entraîné ni déployé de politique nous-mêmes en l’écrivant, et les deux projets évoluent. Considérez les commandes comme le point de départ documenté et vérifiez-les avec la version du code que vous téléchargez.
Choisir le projet d’entraînement adapté à votre robot
Il existe deux projets d’entraînement apparentés, et le modèle du robot compte plus que le code. Une politique apprend la masse, la géométrie et le comportement des servos du robot sur lequel elle a été entraînée : une politique de marche entraînée pour un canard peut tomber immédiatement sur l’autre.
microduck_rl, de Pollen Robotics, entraîne le Microduck d’origine, un bipède d’environ 800 g et 25 cm équipé de 14 servos Dynamixel XL330. xgoduck_rl, de Luwu Dynamics, reprend les mêmes recettes de tâches pour l’adaptation Arduino UNO Q, dont la géométrie et l’inertie diffèrent et dont le simulateur modélise des servos de la famille 1910 au lieu du XL330. Les kits Microduck Robot de ce site sont construits autour de l’UNO Q : commencez donc par xgoduck_rl et vérifiez le modèle de servo de votre montage.
Faites défiler horizontalement pour comparer toutes les colonnes.
| microduck_rl (Pollen Robotics) | xgoduck_rl (Luwu Dynamics) | |
|---|---|---|
| Robot | Microduck d’origine, environ 800 g et 25 cm de haut | L’adaptation Arduino UNO Q |
| Modèle de servo en simulation | Dynamixel XL330 (modèle BAM M6) | Servo de la famille 1910 (modèle BAM HLS1910) |
| Les noms de tâches se terminent par | -MicroDuck | -XgoDuck |
| Pile d’entraînement | mjlab sur MuJoCo Warp, PPO | mjlab sur MuJoCo Warp, PPO |
| Licence | Apache 2.0 pour le code ; les modèles 3D sous CC BY-NC-SA 4.0 | Apache 2.0 |
Comment fonctionne la boucle d’entraînement
Les deux projets reposent sur mjlab, qui exécute la physique MuJoCo sur le GPU via MuJoCo Warp et entraîne avec PPO (proximal policy optimization) de rsl_rl. Les commandes documentées font tourner 4 096 robots simulés en parallèle : une heure d’entraînement représente ainsi des milliers d’heures de pratique simulée.
Chaque compétence est une tâche distincte avec sa propre politique. Une tâche de vitesse apprend à marcher en suivant des consignes de vitesse. Une tâche de relevé apprend à se mettre debout depuis le ventre, le dos ou la position assise. D’autres tâches apprennent à s’asseoir et se lever sur commande, s’accroupir et toucher le sol, frapper un ballon, faire une roulade avant par-dessus la tête ou patiner sur des roues passives. Le projet d’origine entraîne ses politiques à 50 Hz.
Les récompenses et la randomisation se trouvent dans la configuration de chaque tâche. Le projet d’origine documente ses règles de conception des récompenses et regroupe les interrupteurs de randomisation de domaine sous forme de flags ENABLE_* en tête du fichier de configuration de chaque tâche : vous voyez donc ce qui est randomisé avant de lancer un entraînement.
Ce qu’il vous faut avant de commencer
Le robot n’est pas nécessaire pour entraîner une politique ni pour la vérifier en simulation. Il ne sert qu’au test final.
- Un ordinateur avec un GPU NVIDIA compatible CUDA. L’entraînement s’exécute sur le GPU via MuJoCo Warp ; l’ordinateur embarqué du robot n’entraîne rien.
- Python 3.12 et uv, le gestionnaire de paquets Python que les deux projets utilisent pour installer leurs dépendances figées.
- Le code source d’entraînement : xgoduck_rl de Luwu Dynamics pour la version UNO Q, ou microduck_rl de Pollen Robotics pour le Microduck d’origine. Notre documentation technique cite les deux projets.
- Facultatif : un compte Weights & Biases ou Hugging Face. Le projet d’origine sait rejouer et exporter des entraînements enregistrés dans Weights & Biases, et explique comment lancer l’entraînement sur Hugging Face Jobs si vous n’avez pas de GPU local.
Installer l’environnement d’entraînement
À la racine du projet téléchargé, uv sync crée l’environnement à partir du fichier de verrouillage du projet. Lancez-le dans xgoduck_rl, ou dans microduck_rl pour le robot d’origine.
cd xgoduck_rl
uv syncSur les machines ARM comme DGX Spark (GB10) ou Jetson, la première synchronisation télécharge une grosse wheel CUDA (environ 2 Go selon le projet d’origine), et le délai HTTP par défaut de uv, 30 secondes, peut l’interrompre. Augmentez ce délai pour la première synchronisation.
UV_HTTP_TIMEOUT=600 uv syncListez ensuite les tâches enregistrées. Utilisez une tâche dont le nom se termine par -XgoDuck pour la version UNO Q et par -MicroDuck pour le robot d’origine.
uv run list-envsEntraîner une politique de marche
Commencez par la tâche de vitesse sur sol plat. C’est la tâche principale des deux projets : le robot apprend à marcher en suivant des consignes de vitesse.
uv run train Mjlab-Velocity-Flat-XgoDuck --env.scene.num-envs 4096Pour le Microduck d’origine, le projet estime qu’il faut une à deux heures pour obtenir une démarche exploitable avec 4 096 environnements. Luwu Dynamics ne publie pas de durée pour la version UNO Q, et le temps réel dépend de votre GPU.
uv run train Mjlab-Velocity-Flat-MicroDuck --env.scene.num-envs 4096Les checkpoints (model_*.pt) et les journaux TensorBoard sont écrits dans logs/rsl_rl/<experiment>/ ; la tâche de marche utilise logs/rsl_rl/xgoduck_velocity/. Entraînez les autres compétences avec la même commande et un autre nom de tâche, par exemple la tâche de relevé. Le tableau ci-dessous liste les tâches de la version UNO Q ; les descriptions proviennent de la liste des tâches du projet d’origine, dont ces tâches reprennent les recettes.
uv run train Mjlab-StandUp-Flat-XgoDuck --env.scene.num-envs 4096Le projet d’origine explique comment reprendre un entraînement depuis un checkpoint sauvegardé avec les flags d’agent ci-dessous.
uv run train Mjlab-Velocity-Flat-MicroDuck --env.scene.num-envs 4096 \
--agent.run-name resume --agent.load-checkpoint model_29999.pt --agent.resume TrueFaites défiler horizontalement pour comparer toutes les colonnes.
| Tâche (version UNO Q) | Terrain | Ce qu’elle apprend |
|---|---|---|
Mjlab-Velocity-Flat-XgoDuck | Plat | Marcher en suivant des consignes de vitesse |
Mjlab-Velocity-Rough-XgoDuck | Accidenté | La même tâche de marche sur sol irrégulier |
Mjlab-StandUp-Flat-XgoDuck | Plat | Se relever depuis la position couchée ou assise, puis rester debout |
Mjlab-SitStand-Flat-XgoDuck | Plat | S’asseoir et se lever sur commande |
Mjlab-GroundPick-Flat-XgoDuck | Plat | S’accroupir, toucher le sol avec le bec et se relever |
Mjlab-BallKick-Flat-XgoDuck | Plat | Frapper un ballon du pied droit ; une tâche pour le pied gauche existe aussi |
Mjlab-Roulade-Flat-XgoDuck | Plat | Faire une roulade avant par-dessus la tête et retomber sur les pieds |
Mjlab-RollerStandUp-Flat-XgoDuck | Plat | Se relever du sol pour se mettre sur des roues passives |
Mjlab-Velocity-Swizzle-XgoDuck | Plat | Patinage swizzle symétrique sur roues |
Vérifier la politique en simulation
play ouvre le visualiseur d’une tâche. Sans flag de checkpoint, il charge le model_*.pt le plus récent du répertoire d’expérience de cette tâche.
uv run play Mjlab-Velocity-Flat-XgoDuckPour examiner un entraînement précis, passez-lui son fichier de checkpoint. Rejouez exactement le checkpoint que vous comptez exporter, pas seulement le plus récent.
uv run play Mjlab-Velocity-Flat-XgoDuck \
--checkpoint-file logs/rsl_rl/xgoduck_velocity/<run>/model_XXXX.ptSurveillez ce que la récompense peut laisser passer : des pieds qui frottent, une saccade tous les quelques pas, une inclinaison qui augmente avec la vitesse, ou une chute quand la consigne change. Une politique qui paraît instable en simulation ne s’améliorera pas sur le vrai robot.
Réduire l’écart entre simulation et réalité
Avec de petits servos qui animent un bipède léger, les auteurs du projet d’origine estiment que la fidélité des actionneurs représente l’essentiel de l’écart sim-to-real. C’est pourquoi les deux projets modélisent le servo avec BAM (Better Actuator Models, de Rhoban), jusqu’à sa loi de commande en tension, sa force contre-électromotrice et son frottement dépendant de la charge, plutôt qu’avec un régulateur PD idéal.
La randomisation de domaine fait ensuite varier la tension de la batterie, la chute de tension sous charge, le retard de commande et le frottement d’un environnement parallèle à l’autre, afin que la politique ne dépende pas d’un servo précis. Dans le projet d’origine, chaque tâche principale a aussi une variante Backlash qui ajoute ±1° de jeu d’engrenage en série avec chaque articulation de servo : insérez -Backlash avant le nom du robot, par exemple Mjlab-Velocity-Flat-Backlash-MicroDuck.
C’est aussi pour cela que le modèle de servo détermine le projet à utiliser. Entraîner la version UNO Q avec le modèle XL330, ou l’inverse, revient à entraîner la politique pour des servos qui ne sont pas dans votre robot.
Exporter la politique en ONNX
Le script d’export transforme un checkpoint en fichier ONNX et intègre la normalisation des observations dans le graphe. Déployez toujours un fichier produit par scripts/export.py ; un checkpoint converti à la main recevrait des observations non normalisées sur le robot.
uv run python scripts/export.py Mjlab-Velocity-Flat-XgoDuck \
--checkpoint-file logs/rsl_rl/xgoduck_velocity/<run>/model_XXXX.pt \
--onnx-file logs/rsl_rl/xgoduck_velocity/<run>/<run>.onnxSans --onnx-file, la sortie est écrite dans output.onnx dans le répertoire courant. Conservez le fichier exporté à côté de l’entraînement qui l’a produit, et notez la révision du projet d’entraînement, le checkpoint et la somme de contrôle du fichier.
sha256sum logs/rsl_rl/xgoduck_velocity/<run>/<run>.onnxLe projet d’origine permet aussi de piloter une politique exportée au clavier dans MuJoCo sur CPU avec scripts/infer_policy.py. Il simule les servos avec le même modèle BAM que celui de l’entraînement, ce qui en fait une dernière vérification utile avant le robot.
uv run scripts/infer_policy.py --walking output.onnxExécuter la politique sur le robot
Sur le Microduck d’origine, le runtime embarqué de Pollen Robotics charge les politiques exportées et passe de l’une à l’autre (marche, récupération, figure) derrière une observation partagée unique de 61 valeurs : 48 valeurs de proprioception plus des consignes de vitesse du corps, de pose de la tête et de pose du corps. Son outil de publication refuse tout graphe qui n’est pas [1,61] → [1,14], soit une sortie pour chacun des 14 servos.
Pour la version UNO Q, chargez la politique via le runtime correspondant à votre branche de firmware ; notre documentation technique décrit les runtimes. Avant le premier lancement, vérifiez que l’ordre des articulations, les champs d’observation et la normalisation du runtime correspondent à la tâche d’entraînement. Une incohérence se traduit généralement par un robot qui lance une patte ou s’effondre au lieu de tenir debout.
- Chargez la batterie et effectuez la calibration décrite dans le guide de montage, afin que la pose zéro du robot corresponde à la pose zéro du modèle.
- Tenez le robot ou posez-le sur un support pour le premier démarrage, avec l’interrupteur d’alimentation à portée de main.
- Chargez d’abord une politique de station debout ou de relevé, puis la politique de marche avec une faible vitesse de consigne.
- Notez le checkpoint, la somme de contrôle ONNX et la révision du runtime, pour qu’une réparation ultérieure puisse revenir à une combinaison qui fonctionnait.
Dépannage
Si un problème persiste, envoyez-nous la version de votre kit, le projet d’entraînement, le nom de la tâche et une courte vidéo du robot : nous le comparerons aux problèmes de montage que nous connaissons.
uv syncs’arrête en cours de route sur une machine ARM : définissezUV_HTTP_TIMEOUT=600pour la première synchronisation.list-envsn’affiche pas votre tâche : vérifiez le suffixe (-XgoDuckou-MicroDuck) et que vous êtes dans le bon projet.playaffiche un entraînement inattendu : il prend le checkpoint le plus récent du répertoire d’expérience, passez donc--checkpoint-file.- Le robot tremble ou réagit en retard alors que la simulation semble bonne : vérifiez d’abord le modèle de servo, la tension de la batterie et le jeu d’engrenage. C’est précisément ce que la randomisation de domaine est censée couvrir.
- Le robot bouge la mauvaise articulation ou tombe immédiatement : comparez l’ordre des articulations et la structure des observations du runtime avec la tâche d’entraînement, et vérifiez que le fichier a bien été exporté avec
scripts/export.py. - Le robot se tient de travers : recalibrez avant de réentraîner. Une politique ne peut pas corriger un servo dont le zéro est décalé par rapport au modèle.