Entraîner un robot humanoïde avec l’IA et Python

Robots humanoïdes sont des machines qui ressemblent au corps humain par leur forme et leur mouvement, conçues pour travailler aux côtés des personnes et interagir avec nos outils. Il s’agit encore d’une technologie émergente, mais les prévisions prévoient des milliards d’humanoïdes d’ici 2050. Actuellement, les prototypes les plus avancés sont NÉO par 1XTech, Optimus par Tesla, Atlas par Boston Dynamicset G1 par le chinois Unitree Robotics.

Il existe deux manières pour un robot d’effectuer une tâche : le contrôle manuel (lorsque vous programmez spécifiquement ce qu’il doit faire) ou l’intelligence artificielle (il apprend à faire les choses en essayant). En particulier, Apprentissage par renforcement permet à un robot d’apprendre les meilleures actions par essais et erreurs pour atteindre un objectif, afin qu’il puisse s’adapter à des environnements changeants en apprenant des récompenses et des pénalités sans plan prédéfini.

En pratique, il est extrêmement coûteux de faire apprendre à un vrai robot à effectuer une tâche. Par conséquent, les approches de pointe apprennent dans simulation où la génération de données est rapide et bon marché, puis transférer les connaissances au robot réel (approche « sim-to-real » / « sim-first »). Cela permet la formation parallèle de plusieurs modèles dans des environnements de simulation.

Les simulateurs de physique 3D les plus utilisés sur le marché sont : PyBullet (débutants), Bots Web (intermédiaire), MuJoCo (avancé), et Belvédère (professionnels). Vous pouvez utiliser n’importe lequel d’entre eux comme logiciel autonome ou via Salle de sportune bibliothèque créée par OpenAI pour développer Algorithmes d’apprentissage par renforcement, construits sur différents moteurs physiques.

Dans ce tutoriel, je vais montrer comment construire une simulation 3D pour un robot humanoïde avec Intelligence Artificielle. Je présenterai du code Python utile qui peut être facilement appliqué dans d’autres cas similaires (il suffit de copier, coller, exécuter) et de parcourir chaque ligne de code avec des commentaires afin que vous puissiez reproduire cet exemple (lien vers le code complet à la fin de l’article).

Installation

Un environnement est un espace simulé où les agents peuvent interagir et apprendre à effectuer une tâche. Il dispose d’un espace d’observation défini (les informations que les agents reçoivent) et d’espaces d’action (l’ensemble des actions possibles).

j’utiliserai Salle de sport (pip install gymnasium) pour charger l’un des environnements par défaut créés avec MuJoCo (Dynamique Multi-Articulaire avec Contact, pip install mujoco).

import gymnasium as gym

env = gym.make("Humanoid-v4", render_mode="human")
obs, info = env.reset()
env.render()

L’agent est un robot bipède 3D capable de se déplacer comme un humain. Il en a 12 links (parties du corps solide) et 17 articulations (parties du corps flexibles). Vous pouvez voir le description complète ici.

Avant de démarrer une nouvelle simulation, vous devez réinitialiser l’environnement avec obs, info = env.reset(). Cette commande renvoie des informations sur l’état initial de l’agent. Le info comprend généralement des informations supplémentaires sur le robot.

Alors que le obs est ce que l’agent voit (c’est-à-dire avec des capteurs), un modèle d’IA devrait traiter ces observations pour décider quelle action entreprendre.

Habituellement, tout Salle de sport environnements ont la même structure. La première chose à vérifier est le espace d’actionl’ensemble de toutes les actions possibles. Pour la simulation Humanoïde, une action représente la force appliquée à l’une de ses 17 articulations (dans une plage de -0,4 et +0,4 pour indiquer la direction de la poussée).

env.action_space

env.action_space.sample()

Une simulation doit couvrir au moins un épisodeune exécution complète de l’agent interagissant avec l’environnement, du début à la fin. Chaque épisode est une boucle de reset() -> step() -> render(). Prenons un exemple exécutant un seul épisode avec l’humanoïde faisant actions aléatoiresdonc pas l’IA.

import time

env = gym.make("Humanoid-v4", render_mode="human")
obs, info = env.reset()

reset = False #reset if the humanoid falls or the episode ends
episode = 1
total_reward, step = 0, 0

for _ in range(240):
    ## action
    step += 1
    action = env.action_space.sample() #random action
    obs, reward, terminated, truncated, info = env.step(action)
    ## reward
    total_reward += reward
    ## render
    env.render() #render physics step (CPU speed = 0.1 seconds)
    time.sleep(1/240) #slow down to real-time (240 steps × 1/240 second sleep = 1 second)
    if (step == 1) or (step % 100 == 0): #print first step and every 100 steps
        print(f"EPISODE {episode} - Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}")
    ## reset
    if reset:
        if terminated or truncated: #print the last step
            print(f"EPISODE {episode} - Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}")
            obs, info = env.reset()
            episode += 1
            total_reward, step = 0, 0
            print("------------------------------------------")

env.close()

Au fur et à mesure que l’épisode continue et que le robot bouge, nous recevons un récompense. Dans ce cas, c’est positif si l’agent reste debout ou avance, et c’est négatif s’il tombe et touche le sol. La récompense est le concept le plus important pour l’IA car elle définit l’objectif. C’est le signal de retour que nous recevons de l’environnement après chaque action, indiquant si cette action a été utile ou non. Il peut donc être utilisé pour optimiser la prise de décision du robot grâce à l’apprentissage par renforcement.

Apprentissage par renforcement

A chaque étape de la simulation, le l’agent observe la situation actuelle (c’est-à-dire sa position dans l’environnement), décide de passer à l’action (c’est-à-dire bouge une de ses articulations), et reçoit une réponse positive ou négative (récompense, pénalité). Ce cycle se répète jusqu’à la fin de la simulation. RL est un type de Machine Learning qui amène l’agent à maximiser la récompense par essais et erreurs. Ainsi, en cas de succès, le robot saura quelle est la meilleure marche à suivre.

Mathématiquement, RL est basé sur le Processus de décision markoviendans lequel l’avenir ne dépend que de la situation présente, et non du passé. En termes simples, l’agent n’a pas besoin de mémoriser les étapes précédentes pour décider quoi faire ensuite. Par exemple, un robot n’a besoin que de connaître sa position et sa vitesse actuelles pour choisir son prochain mouvement, il n’a pas besoin de se rappeler comment il y est arrivé.

RL consiste à maximiser la récompense. Ainsi, tout l’art de construire une simulation consiste à concevoir une fonction de récompense qui reflète réellement ce que vous voulez (ici le but n’est pas de tomber). L’algorithme RL le plus basique met à jour la liste des actions préférées après avoir reçu une récompense positive. La vitesse à laquelle cela se produit est la taux d’apprentissage: si ce nombre est trop élevé, l’agent surcorrigera, tandis que s’il est trop faible, il continuera à faire les mêmes erreurs et à apprendre terriblement lentement.

Les mises à jour des actions préférées sont également affectées par le taux d’explorationqui est la fréquence d’un choix aléatoire, c’est essentiellement le niveau de curiosité de l’IA. Habituellement, il est relativement élevé au début (lorsque l’agent ne sait rien) et décroît avec le temps à mesure que le robot exploite ses connaissances.

import gymnasium as gym
import time
import numpy as np

env = gym.make("Humanoid-v4", render_mode="human")
obs, info = env.reset()

reset = True #reset if the humanoid falls or the episode ends
episode = 1
total_reward, step = 0, 0
exploration_rate = 0.5 #start wild
preferred_action = np.zeros(env.action_space.shape) #knowledge to update with experience

for _ in range(1000):
    ## action
    step += 1
    exploration = np.random.normal(loc=0, scale=exploration_rate, size=env.action_space.shape) #add random noise
    action = np.clip(a=preferred_action+exploration, a_min=-1, a_max=1)
    obs, reward, terminated, truncated, info = env.step(action) 
    ## reward
    total_reward += reward
    if reward > 0:
        preferred_action += (action-preferred_action)*0.05 #learning_rate
    exploration_rate = max(0.05, exploration_rate*0.99) #min_exploration=0.05, decay_exploration=0.99
    ## render
    env.render() 
    time.sleep(1/240)
    if (step == 1) or (step % 100 == 0):
        print(f"EPISODE {episode} - Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}")
    ## reset
    if reset:
        if terminated or truncated:
            print(f"EPISODE {episode} - Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}")
            obs, info = env.reset()
            episode += 1
            total_reward, step = 0, 0
            print("------------------------------------------")

env.close()

Évidemment, c’est beaucoup trop basique pour un environnement complexe comme l’Humanoïde, donc l’agent continuera à chuter même s’il met à jour ses actions préférées.

Apprentissage par renforcement profond

Lorsque la relation entre les actions et les récompenses n’est pas linéaire, vous avez besoin Réseaux de neurones. Deep RL peut gérer des entrées de grande dimension et estimer les récompenses futures attendues des actions en tirant parti de la puissance des réseaux de neurones profonds.

En Python, le moyen le plus simple d’utiliser les algorithmes Deep RL consiste à Ligne de base stableune collection des modèles les plus connus, déjà pré-implémentés et prêts à l’emploi. Veuillez noter qu’il y a Ligne de base stable (écrit en TensorFlow) et Lignes de base stables3 (écrit en PyTorch). De nos jours, tout le monde utilise ce dernier.

pip install torch
pip install stable-baselines3

L’un des algorithmes Deep RL les plus couramment utilisés est PPO (Optimisation des politiques proximales) car il est simple et stable. L’objectif du PPO est de maximiser la récompense totale attendue, tout en apportant de petites mises à jour à cette politique, en maintenant la croissance stable.

je vais utiliser Ligne de base stable former un OPP sur le Salle de sport Humanoïde environnement. Il y a quelques points à garder à l’esprit :

• nous n’avons pas besoin de restituer l’environnement graphiquement, la formation peut donc se dérouler à une vitesse accélérée.
• Le Salle de sport env doit être enveloppé dans DummyVecEnv pour le rendre compatible avec Ligne de base stable format vectorisé.
• Concernant le modèle de réseau neuronal, PPO utilise un Perceptron multicouche (MlpPolicy) pour les entrées numériques, une Convolution NN (CnnPolicy) pour les images, et un modèle combiné (MultiInputPolicy) pour les observations de types mixtes.
• Puisque je ne fais pas le rendu de l’humanoïde, je trouve très utile de regarder les progrès de l’entraînement sur Tableau Tenseurune boîte à outils pour visualiser les statistiques en temps réel (pip install tensorboard). J’ai créé un dossier nommé « logs » et je peux simplement exécuter tensorboard --logdir=logs/ sur le terminal pour servir le tableau de bord localement (http://localhost:6006/).

from stable_baselines3 import PPO
from stable_baselines3.common.vec_env import DummyVecEnv

## environment
env = gym.make("Humanoid-v4") #no rendering to speed up
env = DummyVecEnv([lambda:env])

## train
print("Training START")
model = PPO(policy="MlpPolicy", env=env, verbose=0, 
            learning_rate=0.005, ent_coef=0.005, #exploration
            tensorboard_log="logs/") #>tensorboard --logdir=logs/

model.learn(total_timesteps=3_000_000, #1h
            tb_log_name="model_humanoid", log_interval=10)
print("Training DONE")

## save
model.save("model_humanoid")

Une fois la formation terminée, nous pouvons charger le nouveau modèle et test dans l’environnement rendu. Désormais, l’agent ne mettra plus à jour les actions préférées. Au lieu de cela, il utilisera le modèle entraîné pour prédire la prochaine meilleure action compte tenu de l’état actuel.

env = gym.make("Humanoid-v4", render_mode="human")
model = PPO.load(path="model_humanoid", env=env)
obs, info = env.reset()

reset = False #reset if the humanoid falls or the episode ends
episode = 1
total_reward, step = 0, 0

for _ in range(1000):
    ## action
    step += 1
    action, _ = model.predict(obs)    
    obs, reward, terminated, truncated, info = env.step(action) 
    ## reward
    total_reward += reward
    ## render
    env.render() 
    time.sleep(1/240)
    if (step == 1) or (step % 100 == 0): #print first step and every 100 steps
        print(f"EPISODE {episode} - Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}")
    ## reset
    if reset:
        if terminated or truncated: #print the last step
            print(f"EPISODE {episode} - Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}")
            obs, info = env.reset()
            episode += 1
            total_reward, step = 0, 0
            print("------------------------------------------")

env.close()

Veuillez noter qu’à aucun moment dans le didacticiel nous n’avons spécifiquement programmé le robot pour qu’il reste debout. Nous ne contrôlons pas l’agent. Le robot réagit simplement à la fonction de récompense de son environnement. En fait, si vous entraînez le modèle RL beaucoup plus longtemps (c’est-à-dire 30 millions de pas de temps), vous commencerez à voir le robot non seulement parfaitement debout, mais aussi avancer. Ainsi, lorsqu’il s’agit de former un agent à l’IA, la conception du monde 3D et de ses règles est plus importante que la construction du robot lui-même.

Conclusion

Cet article a été un tutoriel pour introduire MuJoCo et Salle de sport, et comment créer des simulations 3D pour la robotique. Nous avons utilisé l’environnement humanoïde pour apprendre les bases de l’apprentissage par renforcement. Nous avons formé un réseau neuronal profond pour apprendre au robot à ne pas tomber. De nouveaux tutoriels avec des robots plus avancés arriveront.

Code complet pour cet article : GitHub

J’espère que vous l’avez apprécié ! N’hésitez pas à me contacter pour des questions et des commentaires ou simplement pour partager vos projets intéressants.

👉 Connectons-nous 👈

_{^{(Toutes les images sont de l’auteur, sauf indication contraire)}}