Puppo, le Corgi : Surcharge de mignonnerie avec le ML-Agents Toolkit Unity
Construire un jeu est un processus créatif qui implique de nombreuses étapes difficiles, y compris la définition du concept et de la logique du jeu, la création d'actifs et d'animations, la spécification des comportements des PNJ, l'ajustement de la difficulté et de l'équilibre, et enfin, le test du jeu avec de vrais joueurs avant le lancement. Nous croyons que l'apprentissage automatique peut être utilisé dans l'ensemble du processus créatif et dans le billet de blog d'aujourd'hui, nous allons nous concentrer sur l'un de ces défis : spécifier le comportement d'un PNJ.
Traditionnellement, le comportement d'un PNJ est codé en dur à l'aide de scripts et d'arbres de comportement. Ces listes de règles (généralement longues) traitent les informations sur l'environnement du PNJ (appelées observations) pour dicter sa prochaine action. Ces règles peuvent prendre du temps à écrire et à maintenir à mesure que le jeu évolue. L'apprentissage par renforcement offre un cadre alternatif prometteur pour définir le comportement d'un PNJ. Plus précisément, au lieu de définir manuellement la correspondance observation-action, vous pouvez simplement entraîner votre PNJ en lui fournissant des récompenses lorsqu'il atteint l'objectif souhaité.
Entraîner un PNJ en utilisant l'apprentissage par renforcement est assez similaire à la façon dont nous entraînons un chiot à rapporter. Nous présentons au chiot une friandise, puis nous lançons le bâton. Au début, le chiot se promène sans savoir quoi faire, jusqu'à ce qu'il prenne finalement le bâton et le ramène, recevant rapidement une friandise. Après quelques séances, le chiot apprend que rapporter un bâton est le meilleur moyen d'obtenir une friandise et continue de le faire.
C'est précisément ainsi que fonctionne l'apprentissage par renforcement dans l'entraînement du comportement d'un PNJ. Nous fournissons à notre PNJ une récompense chaque fois qu'il accomplit une tâche correctement. À travers de multiples simulations du jeu (l'équivalent de nombreuses séances de rapport), le PNJ construit un modèle interne de l'action qu'il doit effectuer à chaque instant pour maximiser sa récompense, ce qui entraîne le comportement idéal souhaité. Ainsi, au lieu de créer et de maintenir des actions de bas niveau pour chaque observation du PNJ, nous n'avons besoin de fournir qu'une récompense de haut niveau lorsque la tâche est accomplie correctement et le PNJ apprend le comportement de bas niveau approprié.
Pour démontrer l'efficacité de cette technique, nous avons construit un jeu de démonstration, “Puppo (se lit ‘Pup-o’), le Corgi”, et l'avons présenté à Unite Berlin. C'est un jeu mobile où vous jouez à rapporter avec un adorable petit corgi. Lancez un bâton à Puppo en glissant sur l'écran et Puppo le ramène. Alors que la logique de jeu de haut niveau utilise un script traditionnel, le corgi apprend à marcher, courir, sauter et rapporter le bâton en utilisant l'apprentissage par renforcement. Au lieu d'utiliser des animations ou des comportements scriptés, les mouvements du corgi sont uniquement entraînés avec l'apprentissage par renforcement. Non seulement il a l'air super mignon, mais le mouvement du corgi est exclusivement piloté par le moteur physique. Cela signifie par exemple que le mouvement du corgi peut être affecté par des RigidBodies environnants.
Puppo est devenu si populaire à Unite Berlin que de nombreux développeurs nous ont demandé comment nous l'avons fait. C'est pourquoi nous avons décidé d'écrire cet article de blog et de publier le projet pour que vous puissiez l'essayer vous-même.
Pour commencer, nous allons couvrir les exigences et le travail préliminaire que vous devez faire pour entraîner le corgi. Ensuite, nous partagerons notre expérience dans son entraînement. Enfin, nous passerons en revue les étapes que nous avons suivies pour créer un jeu avec Puppo comme héros.
Avant d'entrer dans les détails, définissons quelques notions importantes dans l'apprentissage par renforcement. L'objectif de l'apprentissage par renforcement est d'apprendre une politique pour un agent. Un agent est une entité qui interagit avec son environnement : À chaque étape d'apprentissage, l'agent collecte des observations sur l'état de l'environnement, effectue une action, et reçoit une récompense pour cette action. La politique définit comment un agent agit en fonction des observations qu'il perçoit. Nous pouvons développer une politique en récompensant l'agent lorsque son comportement est approprié.
Dans notre cas, l'environnement est la scène de jeu et l'agent est Puppo. Puppo doit apprendre une politique afin de pouvoir jouer à rapporter avec nous. De la même manière que nous entraînons un vrai chien avec des friandises pour rapporter des bâtons, nous pouvons entraîner Puppo en le récompensant de manière appropriée.
Nous avons utilisé un ragdoll pour créer Puppo et ses jambes sont entraînées par des moteurs articulés. Par conséquent, pour que Puppo apprenne à atteindre la cible, il doit d'abord apprendre à faire tourner les moteurs des articulations afin de pouvoir se déplacer.
Un vrai chien utilise la vision et d'autres sens pour s'orienter et décider où aller. Puppo suit la même méthodologie. Il collecte des observations sur la scène telles que la proximité de la cible, la position relative entre lui-même et la cible et l'orientation de ses propres pattes, afin de pouvoir décider quelle action entreprendre ensuite. Dans le cas de Puppo, l'action décrit comment faire tourner les moteurs des articulations pour se déplacer.
Après chaque action que Puppo effectue, nous donnons une récompense à l'agent. La récompense est composée de :
- Bonus d'Orientation: Nous récompensons Puppo lorsqu'il se déplace vers la cible. Pour ce faire, nous utilisons la méthode Vector3.Dot().
- Pénalité de Temps: Nous donnons une pénalité fixe (récompense négative) à Puppo à chaque action. De cette façon, Puppo apprendra à obtenir le bâton aussi vite que possible pour éviter une lourde pénalité de temps.
- Pénalité de Rotation: Nous pénalisons Puppo pour avoir essayé de tourner trop. Un vrai chien serait étourdi s'il tourne trop. Pour que cela semble réel, nous pénalisons Puppo lorsqu'il tourne trop vite.
- Récompense d'Atteinte de la cible: Plus important encore, nous récompensons Puppo pour avoir atteint la cible.
Maintenant, Puppo est prêt à apprendre. Il nous a fallu deux heures sur un ordinateur portable pour que le chien apprenne à courir vers la cible de manière efficace. Au cours du processus d'entraînement, nous avons remarqué un comportement intéressant. Le chien a appris à marcher assez rapidement en environ 1 minute. Ensuite, au fur et à mesure que l'entraînement se poursuivait, le chien a appris à courir. Peu après, il a commencé à se retourner lorsqu'il essayait de faire un virage brusque en courant. Heureusement, le chien a appris à se relever tout comme un vrai chien le ferait. Ce comportement maladroit est si mignon que vous pourriez arrêter l'entraînement à ce stade et l'utiliser directement dans le jeu.
Si vous êtes intéressé à entraîner Puppo vous-même, vous pouvez suivre les instructions dans le projet. Il comprend des étapes détaillées sur la façon de configurer l'entraînement et quels paramètres vous devriez choisir. Pour un tutoriel plus détaillé sur la façon d'entraîner des agents, veuillez visiter le site de documentation des ML-Agents.
Pour créer le jeu « Puppo, Le Corgi », nous devons définir la logique du jeu qui permet à un joueur d'interagir avec le modèle entraîné. Parce que Puppo a appris à courir vers une cible, nous devons mettre en œuvre la logique qui change la cible pour Puppo dans le jeu.
En mode jeu, nous définissons la cible comme étant le bâton juste après que le joueur l'ait lancé. Lorsque Puppo arrive au bâton, nous changeons la cible de Puppo pour la position du joueur dans la scène afin que Puppo ramène le bâton au joueur. Nous faisons cela parce qu'il est beaucoup plus facile d'entraîner Puppo à se déplacer vers une cible tout en définissant la logique du flux de jeu avec un script. Nous croyons que l'apprentissage automatique et les méthodes traditionnelles de développement de jeux peuvent être combinés pour tirer le meilleur des deux approches. Le projet « Puppo, Le Corgi » comprend un modèle pré-entraîné pour le corgi que vous pouvez utiliser immédiatement et même déployer sur des appareils mobiles.
Nous espérons que cet article de blog a éclairé ce qui est réalisable avec le ML-Agents Toolkit pour le développement de jeux.
Vous voulez plonger dans le code de ce projet ? Nous avons publié le projet et vous pouvez le télécharger ici. Pour en savoir plus sur l'utilisation du ML-Agents Toolkit, vous pouvez trouver notre documentation officielle et un guide du débutant étape par étape ici. Si vous êtes intéressé par une compréhension plus approfondie des mathématiques, des algorithmes et des théories derrière l'apprentissage par renforcement, il y a un Nanodegree en Apprentissage par Renforcement que nous proposons en partenariat avec Udacity.
Nous aimerions connaître votre expérience avec le ML-Agents Toolkit pour vos jeux. N'hésitez pas à nous contacter sur notre page des problèmes GitHub ou à nous envoyer un email directement.
Bonne création !