🚺 🎌 😕 Agents d'apprentissage automatique chez Unity 🤗 👨🏾‍🔧 💕

Cet article sur les agents d'apprentissage automatique chez Unity a été écrit par Michael Lanham, un innovateur technique, développeur actif pour Unity, consultant, gestionnaire et auteur de nombreux jeux, projets graphiques et livres Unity.

Les développeurs Unity ont implémenté la prise en charge de l'apprentissage automatique, et en particulier de l'apprentissage par renforcement pour la création de SDK d'apprentissage par renforcement profond (DRL) pour les développeurs de jeux et de simulation. Heureusement, l'équipe Unity, dirigée par Danny Lange, a réussi à mettre en œuvre un moteur DRL fiable et moderne capable de fournir des résultats impressionnants. Unity utilise le modèle d'optimisation de politique proximale (PPO) comme base du moteur DRL; ce modèle est beaucoup plus complexe et peut différer à certains égards.

Dans cet article, je vais vous présenter les outils et les SDK pour créer des agents DRL dans les jeux et les simulations. Malgré la nouveauté et la puissance de cet outil, il est facile à utiliser et il dispose d'outils auxiliaires qui vous permettent d'apprendre des concepts d'apprentissage automatique en déplacement. Pour travailler avec le didacticiel, vous devez installer le moteur Unity.

Installer des agents ML

Dans cette section, je parlerai brièvement des étapes à suivre pour installer le SDK ML-Agents. Ce matériel est toujours en version bêta et peut varier d'une version à l'autre. Suivez ces étapes:

Installez Git sur l'ordinateur; Cela fonctionne à partir de la ligne de commande. Git est un système de gestion de code source très populaire, et il existe de nombreuses ressources sur Internet concernant l'installation et l'utilisation de Git sur toutes les plateformes. Après avoir installé Git, assurez-vous que cela fonctionne en créant un clone de n'importe quel référentiel.
Ouvrez une invite de commande ou un shell standard. Les utilisateurs de Windows peuvent ouvrir la fenêtre Anaconda.
Accédez au dossier de travail dans lequel vous souhaitez placer votre nouveau code et entrez la commande suivante (les utilisateurs Windows peuvent sélectionner C: \ ML-Agents):
```
  git clone https://github.com/Unity-Technologies/ml-agents 
```
Vous clonez donc le référentiel ml-agents sur votre ordinateur et créez un nouveau dossier du même nom. Vous pouvez également ajouter un numéro de version au nom du dossier. L'unité, comme presque tout le monde de l'intelligence artificielle, est en constante évolution, du moins pour l'instant. Cela signifie que de nouveaux changements apparaissent constamment. Au moment de l'écriture, nous clonons le référentiel dans le dossier ml-agents.6:
```
  git clone https://github.com/Unity-Technologies/ml-agents ml-agents.6 
```

Créez un nouvel environnement virtuel pour ml-agents et spécifiez la version 3.6, comme ceci:

  #Windows 
 conda create -n ml-agents python = 3,6
 
 #Mac
 Utilisez la documentation de votre environnement préféré

Réactivez votre environnement avec Anaconda:
```
  activer les agents ml 
```
Installez TensorFlow. Dans Anaconda, cela peut être fait avec la commande suivante:
```
  pip install tensorflow == 1.7.1 
```

Installez les packages Python. Dans Anaconda, entrez les informations suivantes:

cd ML-Agents #from root folder cd ml-agents or cd ml-agents.6 #for example cd ml-agents pip install -e . or pip3 install -e .

Vous installez donc tous les packages SDK d'agents nécessaires; cela peut prendre plusieurs minutes. Ne fermez pas la fenêtre, elle vous sera bientôt utile.

Nous avons donc installé et configuré le SDK Unity Python pour ML-Agents. Dans la section suivante, nous apprendrons comment configurer et former l'un des nombreux environnements fournis par Unity.

Formation d'agent

Nous pouvons maintenant passer immédiatement aux choses sérieuses et explorer des exemples qui utilisent l'apprentissage par renforcement profond (DRL). Heureusement, il existe plusieurs exemples dans la boîte à outils du nouvel agent pour démontrer la puissance du moteur. Ouvrez Unity ou Unity Hub et procédez comme suit:

Cliquez sur le bouton Ouvrir un projet en haut de la boîte de dialogue Projet.
Localisez et ouvrez le dossier du projet UnitySDK, comme indiqué dans la capture d'écran:

Ouvrez le projet Unity SDK
Attendez que le projet se charge, puis ouvrez la fenêtre Projet en bas de l'éditeur. Si une fenêtre s'ouvre vous demandant de mettre à jour le projet, sélectionnez oui ou continuez. Actuellement, tout le code d'agent est rétrocompatible.
Localisez et ouvrez la scène GridWorld comme indiqué dans la capture d'écran:

Ouverture d'un exemple de scène GridWorld
Sélectionnez l'objet GridAcademy dans la fenêtre Hiérarchie.
Accédez à la fenêtre Inspecteur et à côté du champ Cerveau, cliquez sur l'icône pour ouvrir la boîte de dialogue de sélection du cerveau:
Sélectionnez le cerveau du GridWorldPlayer. Ce cerveau appartient au joueur, c'est-à-dire que le joueur (vous) peut contrôler le jeu.
Cliquez sur le bouton Lecture en haut de l'éditeur et observez l'environnement. Le jeu étant désormais configuré pour contrôler le joueur, vous pouvez utiliser les touches WASD pour déplacer le cube. La tâche consiste à déplacer le cube bleu vers le symbole vert +, tout en évitant le X rouge.

Mettez-vous à l'aise dans le jeu. Notez que le jeu ne fonctionne que pendant une certaine période de temps et n'est pas au tour par tour. Dans la section suivante, nous apprendrons comment exécuter cet exemple avec l'agent DRL.

Qu'y a-t-il dans le cerveau?

L'un des aspects étonnants de la plate-forme ML-Agents est la possibilité de passer rapidement et facilement de la gestion des joueurs à la gestion de l'IA / des agents. Pour cela, Unity utilise le concept de «cerveau». Le cerveau peut être contrôlé soit par le joueur, soit par l'agent (cerveau apprenant). La chose la plus étonnante est que vous pouvez assembler le jeu et le tester en tant que joueur, puis le donner sous le contrôle d'un agent RL. Grâce à cela, tout jeu écrit avec un peu d'effort peut être fait pour être contrôlé à l'aide de l'IA.

Le processus de configuration et de démarrage de la formation d'agent RL dans Unity est assez simple. Unity utilise Python externe pour construire un modèle du cerveau apprenant. L'utilisation de Python a beaucoup de sens car il existe déjà plusieurs bibliothèques d'apprentissage profond (DL) construites autour de lui. Pour former l'agent dans GridWorld, procédez comme suit:

Sélectionnez à nouveau GridAcademy et sélectionnez GridWorldLearning dans le champ Brains au lieu de GridWorldPlayer:

Passer à l'utilisation de GridWorldLearning Brain
Cochez la case Contrôle à droite. Ce paramètre simple indique que le cerveau peut être contrôlé de l'extérieur. Cette option doit être activée.
Sélectionnez l'objet trueAgent dans la fenêtre Hiérarchie, puis dans la fenêtre Inspecteur, changez la propriété Brain dans le composant Grid Agent en GridWorldLearning brain:

GridWorldLearning emploi de cerveau pour agent
Dans cet exemple, nous avons besoin à la fois de l'Académie et de l'Agent pour utiliser le même cerveau GridWorldLearning. Basculez vers la fenêtre Anaconda ou Python et sélectionnez le dossier ML-Agents / ml-agents.
Exécutez la commande suivante dans une fenêtre Anaconda ou Python à l'aide de l'environnement virtuel ml-agents:
```
  mlagents-learn config / trainer_config.yaml --run-id = firstRun --train 
```
Cela lancera le modèle de formation Unity PPO et un exemple d'agent avec la configuration spécifiée. À un certain moment, la fenêtre d'invite de commandes vous demandera de démarrer l'éditeur Unity avec l'environnement chargé.
Cliquez sur Lecture dans l'éditeur Unity pour lancer l'environnement GridWorld. Peu de temps après, vous devriez voir la formation de l'agent et la sortie vers la fenêtre de script Python:

Exécuter GridWorld en mode d'apprentissage
Notez que le script mlagents-learn est un code Python qui construit un modèle RL pour exécuter un agent. Comme vous pouvez le voir sur la sortie du script, plusieurs paramètres (hyperparamètres) doivent être configurés.
Laissez l'agent apprendre quelques milliers d'itérations et notez à quelle vitesse il apprend. Le modèle interne utilisé ici appelé PPO s'est avéré être un modèle d'apprentissage très efficace pour de nombreuses tâches différentes, et il est très bien adapté au développement de jeux. Avec un équipement suffisamment puissant, un agent peut idéalement apprendre en moins d'une heure.

Laissez l’agent apprendre davantage et explorez d’autres moyens de suivre le processus d’apprentissage de l’agent, comme indiqué dans la section suivante.

Surveillance de l'apprentissage avec TensorBoard

La formation d'un agent à l'aide du modèle RL ou de tout modèle DL est souvent une tâche ardue et nécessite une attention aux détails. Heureusement, TensorFlow dispose d'un ensemble d'outils graphiques appelés TensorBoard que vous pouvez utiliser pour surveiller votre processus d'apprentissage. Suivez ces étapes pour démarrer TensorBoard:

Ouvrez une fenêtre Anaconda ou Python. Activez l'environnement virtuel ml-agents. Ne fermez pas la fenêtre dans laquelle le modèle de formation s'exécute; nous en avons besoin pour continuer.
Accédez au dossier ML-Agents / ml-agents et exécutez la commande suivante:
```
  tensorboard --logdir = résumés 
```
Nous lançons donc TensorBoard sur notre propre serveur Web intégré. Vous pouvez charger la page en utilisant l'URL indiquée après la commande précédente.
Saisissez l'URL du TensorBoard comme indiqué dans la fenêtre ou saisissez localhost: 6006 ou machinename: 6006 dans le navigateur. Après environ une heure, vous devriez voir quelque chose comme ceci:

Fenêtre de graphique TensorBoard
La capture d'écran précédente montre des graphiques, chacun affichant un aspect distinct de la formation. Pour comprendre comment notre agent est formé, vous devez traiter chacun de ces graphiques, nous analyserons donc les résultats de chaque section:

Environnement: cette section montre comment l'agent se manifeste dans l'environnement dans son ensemble. Voici une vue plus détaillée des graphiques avec la tendance préférée:

Une image détaillée des graphiques de la section Environnement

Récompense cumulative: il s'agit de la récompense totale qui maximise l'agent. Habituellement, il est nécessaire qu'il augmente, mais pour une raison quelconque, il peut diminuer. Il est toujours préférable de maximiser les récompenses entre 1 et -1. Si les récompenses de calendrier dépassent cette plage, cela doit également être corrigé.
Durée de l'épisode: si cette valeur diminue, c'est généralement un bon signe. En fin de compte, plus les épisodes sont courts, plus l'entraînement est important. Cependant, gardez à l'esprit que si nécessaire, la durée des épisodes peut augmenter, de sorte que l'image peut être différente.
Leçon: ce tableau indique clairement dans quelle leçon l'agent se trouve; Il est destiné à l'apprentissage du curriculum.
Pertes: cette section présente des graphiques représentant les pertes ou les coûts calculés pour la police et la valeur. Voici une capture d'écran de cette section avec des flèches pointant vers les paramètres optimaux:

Pertes et formation préférée

Perte de police: ce graphique détermine la quantité de changement de police au fil du temps. La politique est un élément qui définit les actions, et dans le cas général, ce calendrier devrait tendre à la baisse, montrant que la politique prend de meilleures décisions.
Perte de valeur: il s'agit de la perte moyenne de la fonction de valeur. En substance, il modélise la façon dont l'agent prédit la valeur de son prochain état. Initialement, cette valeur devrait augmenter et après stabilisation de la rémunération, elle devrait diminuer.
Politique: pour évaluer la qualité des actions en PPO, le concept de politique est utilisé, pas un modèle. La capture d'écran ci-dessous montre les graphiques de politique et la tendance préférée:

Graphiques des politiques et tendances privilégiées
Entropie: ce graphique montre l'ampleur de l'agent de recherche. Cette valeur doit être réduite, car l'agent en apprend plus sur l'environnement et a besoin de moins de recherches.
Taux d'apprentissage: dans ce cas, cette valeur devrait diminuer progressivement de façon linéaire.
Estimation de la valeur: il s'agit de la valeur moyenne visitée par tous les États agents. Pour refléter les connaissances accrues d’un agent, cette valeur doit croître puis se stabiliser.

6. Laissez l'agent en cours d'exécution jusqu'à la fin et ne fermez pas le TensorBoard.
7. Revenez à la fenêtre Anaconda / Python qui a entraîné le cerveau et exécutez cette commande:

  mlagents-learn config / trainer_config.yaml --run-id = secondRun --train

8. Il vous sera à nouveau demandé de cliquer sur Lecture dans l'éditeur; faites-le. Laissez l'agent commencer la formation et effectuez plusieurs séances. Dans le processus, regardez la fenêtre TensorBoard et notez comment secondRun est affiché sur les graphiques. Vous pouvez laisser cet agent s'exécuter jusqu'à son terme, mais vous pouvez l'arrêter si vous le souhaitez.

Dans les versions précédentes de ML-Agents, vous deviez d'abord créer l'exécutable Unity comme environnement d'apprentissage pour le jeu, puis l'exécuter. Le cerveau extérieur de Python aurait dû fonctionner de la même manière. Cette méthode a rendu très difficile le débogage des problèmes dans le code ou dans le jeu. Dans la nouvelle technique, toutes ces difficultés ont été éliminées.

Maintenant que nous avons vu à quel point il est facile de configurer et de former l'agent, nous allons passer à la section suivante, dans laquelle nous allons apprendre à exécuter l'agent sans le cerveau externe Python et à l'exécuter directement dans Unity.

Lancement d'agent

La formation en Python est géniale, mais vous ne pouvez pas l'utiliser dans un vrai jeu. Idéalement, nous aimerions créer un graphique TensorFlow et l'utiliser dans Unity. Heureusement, la bibliothèque TensorFlowSharp a été créée qui permet à .NET d'utiliser les graphiques TensorFlow. Cela nous permet de créer des modèles TFModels hors ligne, puis de les injecter dans le jeu. Malheureusement, nous ne pouvons utiliser que des modèles formés, mais pas les former de cette façon, du moins pas encore.

Voyons comment cela fonctionne, en utilisant l'exemple du graphique que nous venons de former pour l'environnement GridWorld; utilisez-le comme un cerveau intérieur dans Unity. Suivez les étapes de la section suivante pour configurer et utiliser votre cerveau intérieur:

Téléchargez le plugin TFSharp ici
Dans le menu de l'éditeur, sélectionnez Actifs | Importer un package | Forfait personnalisé ...
Recherchez le package d'actifs que vous venez de télécharger et utilisez les boîtes de dialogue d'importation pour charger le plugin dans le projet.
Dans le menu, sélectionnez Modifier | Paramètres du projet. La fenêtre Paramètres s'ouvre (apparue dans la version 2018.3)
Recherchez les caractères Scripting Define Symbols dans les options du lecteur et modifiez le texte en ENABLE_TENSORFLOW, et activez également le code Allow Unsafe, comme indiqué dans la capture d'écran:

Définition de l'indicateur ENABLE_TENSORFLOW
Recherchez l'objet GridWorldAcademy dans la fenêtre Hiérarchie et assurez-vous qu'il utilise Brains | GridWorldLearning. Désactivez l'option Control dans la section Brains du script Grid Academy.
Recherchez le cerveau GridWorldLearning dans le dossier Assets / Examples / GridWorld / Brains et assurez-vous que le paramètre Model dans la fenêtre Inspector est défini, comme indiqué dans la capture d'écran:

Tâche modèle pour le cerveau
GridWorldLearning doit déjà être défini comme modèle. Dans cet exemple, nous utilisons le TFModel fourni avec l'exemple GridWorld.
Cliquez sur Lecture pour démarrer l'éditeur et voir comment l'agent gère le cube.

Nous lançons maintenant l'environnement pré-formé Unity. Dans la section suivante, nous apprendrons à utiliser le cerveau que nous avons formé dans la section précédente.

Chargement du cerveau formé

Tous les exemples Unity ont des cerveaux pré-formés qui peuvent être utilisés pour étudier des exemples. Bien sûr, nous voulons pouvoir charger nos propres graphiques TF dans Unity et les exécuter. Pour charger un graphique entraîné, procédez comme suit:

Accédez au dossier ML-Agents / ml-agents / models / firstRun-0. À l'intérieur de ce dossier se trouve le fichier GridWorldLearning.bytes. Faites glisser ce fichier dans le dossier Project / Assets / ML-Agents / Examples / GridWorld / TFModels à l'intérieur de l'éditeur Unity:

Faire glisser un graphique d'octets dans Unity
Nous importons donc le graphique dans le projet Unity en tant que ressource et le renommons en GridWorldLearning 1. Le moteur le fait car le modèle par défaut porte déjà le même nom.
Recherchez GridWorldLearning dans le dossier cerveau, sélectionnez-le dans la fenêtre Inspecteur et faites glisser le nouveau modèle GridWorldLearning 1 dans le champ Modèle des paramètres du cerveau:

Chargement du cerveau dans le champ Graph Model
À ce stade, nous n'avons pas besoin de modifier d'autres paramètres, mais portons une attention particulière à la configuration du cerveau. Pour l'instant, les paramètres standard feront l'affaire.
Cliquez sur Jouer dans l'éditeur Unity et voyez comment l'agent se déplace avec succès dans le jeu.
Le succès de l'agent dans le jeu dépend du temps de sa formation. Si vous lui permettez de suivre la formation, l'agent sera similaire à un agent Unity parfaitement formé.