🌙 🤕 👴🏽 Apprentissage automatique Unity: apprendre aux agents MO à sauter par-dessus les murs 🙍🏾 🎯 🚶🏿

Il y a eu des percées majeures dans l'apprentissage par renforcement (RL) au cours des dernières années: de la première utilisation réussie de celui-ci dans la formation de pixels bruts à la formation de robots AI ouverts, et des environnements de plus en plus sophistiqués sont nécessaires pour de nouveaux progrès, auxquels L'unité vient.

L'outil Unity ML-Agents est un nouveau plugin dans le moteur de jeu Unity, vous permettant d'utiliser Unity comme constructeur d'environnement pour former des agents MO.

De jouer au football à marcher, sauter des murs et apprendre à maîtriser l'IA avec un bâton, Unity ML-Agents Toolkit fournit un large éventail de conditions d'entraînement pour les agents.

Dans cet article, nous verrons comment fonctionnent les agents Unity MO, puis nous apprendrons à l'un de ces agents à sauter par-dessus les murs.

Qu'est-ce que les agents Unity ML?

Unity ML-Agents est un nouveau plugin pour le moteur de jeu Unity, qui vous permet de créer ou d'utiliser des environnements prêts à l'emploi pour former nos agents.

Le plugin se compose de trois composants:

Le premier - un environnement d'apprentissage ( l'environnement d'apprentissage ), contenant des scènes d'Unity et des éléments environnementaux.

La seconde est l' API Python , dans laquelle se trouvent les algorithmes RL (tels que PPO - Proximal Policy Optimization et SAC - Soft Actor-Critic). Nous utilisons cette API pour lancer la formation, les tests, etc. Elle est connectée à l'environnement d'apprentissage via le troisième composant - un communicateur externe .

En quoi consiste l'environnement d'apprentissage

Le volet formation comprend différents éléments:

le premier agent est l'acteur de la scène. C'est lui que nous formerons en optimisant un composant appelé «cerveau», dans lequel il est enregistré quelles actions doivent être effectuées dans chacun des états possibles.

Le troisième élément, l'Académie, gère les agents et leurs processus décisionnels et traite les demandes de l'API Python. Pour mieux comprendre son rôle, rappelons le processus RL. Il peut être représenté comme un cycle qui fonctionne comme suit:

Supposons qu'un agent ait besoin d'apprendre à jouer à un jeu de plateforme. Le processus RL dans ce cas ressemblera à ceci:

L'agent reçoit l'état S ₀ de l'environnement - ce sera la première image de notre jeu.
Sur la base de l'état S _{0, l'} agent exécute l'action A ₀ et se décale vers la droite.
L'environnement passe dans un nouvel état S ₁ .
L'agent reçoit _une récompense R ₁ pour ne pas être mort ( récompense positive +1).

Ce cycle RL forme une séquence d'état, d'action et de récompense. L'objectif de l'agent est de maximiser la récompense totale attendue.

Ainsi, Academy envoie des instructions aux agents et assure la synchronisation de leur exécution, à savoir:

Collection d'observations;
Le choix de l'action conformément aux instructions fixées;
Exécution de l'action;
Réinitialisez si le nombre d'étapes a été atteint ou si l'objectif a été atteint.

Nous apprenons à l'agent à sauter à travers les murs

Maintenant que nous savons comment fonctionnent les agents Unity, nous allons en former un à sauter à travers les murs.

Les modèles déjà formés peuvent également être téléchargés sur GitHub .

Environnement d'apprentissage du saut de mur

Le but de cet environnement est d'apprendre à l'agent à se rendre à la tuile verte.

Prenons trois cas:

1. Il n'y a pas de murs, et notre agent n'a qu'à se rendre sur le carreau.

2. L'agent doit apprendre à sauter pour atteindre la tuile verte.

3. Le cas le plus difficile: le mur est trop haut pour que l'agent puisse sauter dessus, il doit donc d'abord sauter sur le bloc blanc.

Nous apprendrons à l'agent deux scénarios de comportement en fonction de la hauteur du mur:

SmallWallJump dans les cas sans murs ou à faible hauteur de mur;
BigWallJump dans le cas de hauts murs.

Voici à quoi ressemblera le système de récompense:

Dans nos observations, nous n'utilisons pas une trame régulière, mais 14 reykast, chacun pouvant détecter 4 objets possibles. Dans ce cas, le reykast peut être perçu comme des faisceaux laser qui peuvent déterminer s'ils traversent un objet.

Nous utiliserons également la position d'agent mondial dans notre programme.

Quatre options sont possibles dans notre espace:

L'objectif est de réaliser une tuile verte avec une récompense moyenne de 0,8 .

Alors, commençons!

Tout d'abord, ouvrez le projet UnitySDK .

Parmi les exemples, vous devez trouver et ouvrir la scène WallJump .

Comme vous pouvez le voir, il y a de nombreux agents sur scène, chacun provenant du même préfabriqué, et ils ont tous le même «cerveau».

Comme dans le cas du Deep Reinforcement Learning classique, après avoir lancé plusieurs instances du jeu (par exemple, 128 environnements parallèles), il ne nous reste plus qu'à copier et coller les agents pour avoir des états plus différents. Et puisque nous voulons former notre agent à partir de zéro, nous devons d'abord retirer le «cerveau» de l'agent. Pour ce faire, accédez au dossier prefabs et ouvrez Prefab.

Ensuite, dans la hiérarchie Prefab, vous devez sélectionner l'agent et accéder aux paramètres.

Dans les paramètres de comportement, vous devez supprimer le modèle. Si nous avons plusieurs GPU à notre disposition, vous pouvez utiliser le périphérique d'inférence du CPU comme GPU.

Dans le composant Wall Jump Agent, vous devez supprimer les cerveaux pour un boîtier sans murs, ainsi que pour les murs bas et hauts.

Après cela, vous pouvez commencer à former votre agent à partir de zéro.

Pour notre première formation, nous modifions simplement le nombre total d'étapes de formation pour deux scénarios de comportement: SmallWallJump et BigWallJump. Ainsi, nous pouvons atteindre l'objectif en seulement 300 000 étapes. Pour ce faire, dans config / trainer config.yaml, remplacez max_steps par 3e5 pour les cas SmallWallJump et BigWallJump.

Pour former notre agent, nous utiliserons PPO (Proximal Policy Optimization). L'algorithme comprend l'accumulation d'expérience dans l'interaction avec l'environnement et son utilisation pour mettre à jour les politiques décisionnelles. Après sa mise à jour, les événements précédents sont supprimés et la collecte de données suivante est déjà effectuée selon les termes de la politique mise à jour.

Donc, tout d'abord, en utilisant l'API Python, nous devons appeler un communicateur externe afin qu'il ordonne à l'Académie de lancer des agents. Pour ce faire, ouvrez le terminal où se trouve ml-agents-master et saisissez-le:

mlagents-learn config/trainer_config.yaml — run-id=”WallJump_FirstTrain” — train

Cette commande vous demandera de démarrer la scène Unity. Pour ce faire, appuyez sur ► en haut de l'éditeur.

Vous pouvez regarder la formation de vos agents dans Tensorboard avec la commande suivante:

tensorboard — logdir=summaries

Une fois la formation terminée, vous devez déplacer les fichiers de modèle enregistrés contenus dans ml-agents-master / models vers UnitySDK / Assets / ML-Agents / examples / WallJump / TFModels . Ensuite, ouvrez à nouveau l'éditeur Unity et sélectionnez la scène WallJump , où nous ouvrons l'objet WallJumpArea terminé .

Après cela, sélectionnez l'agent et dans ses paramètres de comportement, faites glisser le fichier SmallWallJump.nn dans l' espace réservé au modèle.

Déplacer également:

SmallWallJump.nn à No Wall Brain Placeholder.
SmallWallJump.nn dans l' espace réservé au petit mur de cerveau.
BigWallJump.nn à No Wall Brain Placeholder.

Après cela, appuyez sur le bouton ► en haut de l'éditeur et vous avez terminé! L'algorithme de configuration de la formation des agents est maintenant terminé.

Temps d'expérimentation

La meilleure façon d'apprendre est d'essayer constamment d'apporter quelque chose de nouveau. Maintenant que nous avons déjà obtenu de bons résultats, nous allons essayer de poser quelques hypothèses et de les tester.

Réduire le coefficient d'actualisation à 0,95

Nous savons donc que:

Plus le gamma est grand, plus la remise est faible. Autrement dit, l'agent est plus préoccupé par les récompenses à long terme.
En revanche, plus le gamma est petit, plus la remise est importante. Dans ce cas, la priorité de l'agent est la rémunération à court terme.

L'idée de cette expérience est que si nous augmentons la remise en diminuant la gamme de 0,99 à 0,95, la récompense à court terme sera une priorité pour l'agent - ce qui peut l'aider à aborder rapidement la politique de comportement optimale.

Fait intéressant, dans le cas d'un saut à travers un muret, l'agent s'efforcera d'obtenir le même résultat. Cela peut s'expliquer par le fait que ce cas est assez simple: l'agent n'a qu'à se déplacer vers la tuile verte et, si nécessaire, à sauter s'il y a un mur devant.

En revanche, dans le cas de Big Wall Jump, cela fonctionne moins bien, car notre agent se soucie plus de la récompense à court terme et ne comprend donc pas qu'il doit grimper sur le bloc blanc pour sauter par-dessus le mur.

Augmentation de la complexité du réseau neuronal

Enfin, nous émettons l'hypothèse que notre agent deviendra plus intelligent si nous augmentons la complexité du réseau neuronal. Pour ce faire, augmentez la taille du niveau caché de 256 à 512.

Et nous constatons que dans ce cas le nouvel agent fonctionne moins bien que notre premier agent. Cela signifie que cela n'a aucun sens pour nous d'augmenter la complexité de notre réseau, car sinon le temps d'apprentissage augmentera également.

Nous avons donc formé l'agent à sauter par-dessus les murs, et c'est tout pour aujourd'hui. Rappelons que pour comparer les résultats, des modèles formés peuvent être téléchargés ici .

Apprentissage automatique Unity: apprendre aux agents MO à sauter par-dessus les murs