Comment construire votre propre AlphaZero AI en utilisant Python et Keras

Apprenez à une machine à apprendre la stratégie Connect4 par le jeu personnel et l'apprentissage en profondeur

Dans cet article, je vais essayer de couvrir trois choses:

  1. Deux raisons pour lesquelles AlphaZero représente une avancée considérable pour l'intelligence artificielle
  2. Comment créer une réplique de la méthodologie AlphaZero pour jouer au jeu Connect4
  3. Comment vous pouvez adapter le code pour brancher d'autres jeux

AlphaGo → AlphaGo Zero → AlphaZero

En mars 2016, AlphaGo de Deepmind a battu Lee Sedol 4 à 1, 18 fois champion du monde de Go, dans une série regardée par plus de 200 millions de personnes. Une machine avait appris une stratégie surhumaine pour jouer à Go, exploit que l'on pensait auparavant impossible, ou tout au moins, à au moins dix ans de la réalisation.

Match 3 de AlphaGo contre Lee Sedol

Cela en soi était une réalisation remarquable. Cependant, le 18 octobre 2017, DeepMind a fait un pas de géant supplémentaire.

Le document «Maîtriser le jeu de Go sans connaissance humaine» a dévoilé une nouvelle variante de l’algorithme, AlphaGo Zero, qui avait battu AlphaGo 100–0. Incroyablement, il l’a fait en apprenant uniquement par le jeu personnel, en commençant par la «tabula rasa» (état vide) et en trouvant progressivement des stratégies qui dépasseraient ses incarnations précédentes. Il n'était plus nécessaire de créer une base de données de jeux d'experts humains pour créer une IA surhumaine.

Un graphique de ‘Maîtriser le jeu de Go sans connaissance humaine’

À peine 48 jours plus tard, le 5 décembre 2017, DeepMind publiait un autre document intitulé "Maîtriser les échecs et le shogi en self-play avec un algorithme d'apprentissage du renforcement général", qui montrait comment AlphaGo Zero pourrait être adapté pour battre les programmes du champion du monde StockFish et Elmo aux échecs. et le shogi. Il a fallu moins de 24 heures pour que tout le processus d’apprentissage, qui consiste à montrer les jeux pour la première fois et à devenir le meilleur programme informatique au monde.

AlphaZero est ainsi né - l’algorithme général permettant de réussir rapidement quelque chose, sans aucune connaissance préalable de la stratégie d’un expert humain.

Il y a deux choses étonnantes à propos de cette réalisation:

1. AlphaZero ne requiert aucune expertise humaine

Il ne faut pas exagérer à quel point c'est important. Cela signifie que la méthodologie sous-jacente d’AlphaGo Zero peut être appliquée à TOUT jeu comportant des informations parfaites (l’état du jeu est parfaitement connu des deux joueurs à tout moment) car aucune expertise préalable n’est requise, hormis les règles du jeu.

C’est ainsi que DeepMind n’a pu publier les papiers d’échecs et de shogi que 48 jours après le premier papier AlphaGo Zero. Littéralement, il suffisait de modifier le fichier d'entrée qui décrit les mécanismes du jeu et de modifier les hyper-paramètres relatifs au réseau de neurones et à la recherche d'arbres de Monte-Carlo.

2. L'algorithme est ridiculement élégant

Si AlphaZero utilisait des algorithmes super complexes que seules une poignée de personnes dans le monde comprenaient, ce serait tout de même un exploit incroyable. Ce qui est extraordinaire, c’est que nombre des idées présentées dans le document sont en réalité beaucoup moins complexes que les versions précédentes. En son cœur se trouve le mantra d’apprentissage simple et magnifique:

Jouez mentalement à travers d’éventuels scénarios futurs, en donnant la priorité aux pistes prometteuses, tout en tenant compte de la manière dont les autres sont le plus susceptibles de réagir à vos actions et en continuant à explorer l’inconnu.
Après avoir atteint un état qui vous est inconnu, évaluez dans quelle mesure vous croyez que la situation est favorable et remontez le score en cascade pour revenir aux positions précédentes du chemin mental qui a conduit à ce point.
Une fois que vous avez fini de penser aux possibilités futures, prenez les mesures que vous avez le plus explorées.
À la fin du jeu, revenez en arrière et déterminez où vous avez mal évalué la valeur des positions futures et mettez à jour votre compréhension en conséquence.

Cela ne vous ressemble-t-il pas beaucoup de la façon dont vous apprenez à jouer à des jeux? Lorsque vous jouez un mauvais coup, c’est soit parce que vous avez mal évalué la valeur future des positions résultantes, soit vous avez mal évalué la probabilité que votre adversaire joue un certain coup, alors n’a pas pensé à explorer cette possibilité. Ce sont exactement les deux aspects du jeu que AlphaZero est entraîné à apprendre.

Comment construire votre propre AlphaZero

Tout d’abord, consultez la feuille de triche AlphaGo Zero pour une compréhension approfondie du fonctionnement d’AlphaGo Zero. Cela vaut la peine de s'y référer lorsque nous parcourons chaque partie du code. Vous y trouverez également un excellent article qui explique le fonctionnement plus détaillé d’AlphaZero.

Le code

Clonez ce référentiel Git, qui contient le code que je vais référencer.

Pour démarrer le processus d'apprentissage, exécutez les deux panneaux supérieurs du bloc-notes run.ipynb Jupyter. Une fois que les positions de jeu seront suffisamment nombreuses pour remplir sa mémoire, le réseau de neurones commencera à s’entraîner. Grâce à un jeu personnel et à un entraînement supplémentaires, il sera de mieux en mieux à même de prédire la valeur du jeu et les mouvements suivants, quelle que soit leur position, ce qui se traduira par une meilleure prise de décision et un jeu global plus intelligent.

Nous allons maintenant examiner le code plus en détail et montrer des résultats qui démontrent que l'IA devient plus forte au fil du temps.

NB - C’est ma propre compréhension du fonctionnement d’AlphaZero sur la base des informations disponibles dans les documents susmentionnés. Si l'un des points ci-dessous est incorrect, veuillez nous en excuser et je vais essayer de le corriger!

Connect4

Le jeu que notre algorithme va apprendre à jouer est Connect4 (ou Four In A Row). Pas aussi complexe que Go… mais il reste encore 4 531 985 219 092 positions de jeu.

Connect4

Les règles du jeu sont simples. Les joueurs se relaient pour entrer un morceau de leur couleur en haut de toute colonne disponible. Le premier joueur à avoir quatre couleurs de suite - chacune à la verticale, à l’horizontale ou en diagonale, gagne. Si la grille entière est remplie sans créer une série de quatre dans une rangée, le jeu est tracé.

Voici un résumé des fichiers de clés qui constituent la base de code:

game.py

Ce fichier contient les règles du jeu pour Connect4.

Un numéro compris entre 0 et 41 est attribué à chaque carré:

Carrés d'action pour Connect4

Le fichier game.py donne la logique qui sous-tend le passage d’un état à l’autre, en fonction de l’action choisie. Par exemple, étant donné le tableau vide et l’action 38, la méthode takeAction renvoie un nouvel état de jeu, avec le pion du premier joueur en bas de la colonne centrale.

Vous pouvez remplacer le fichier game.py par n’importe quel fichier de jeu conforme à la même API. En principe, l’algorithme apprendra la stratégie par vous-même, en fonction des règles que vous lui avez données.

run.ipynb

Ceci contient le code qui lance le processus d'apprentissage. Il charge les règles du jeu, puis itère dans la boucle principale de l'algorithme, qui se compose de trois étapes:

  1. Jeu de soi
  2. Recyclage du réseau de neurones
  3. Évaluer le réseau de neurones

Il y a deux agents impliqués dans cette boucle, le best_player et le current_player.

Best_player contient le réseau de neurones le plus performant et est utilisé pour générer les mémoires de jeu automatique. Current_player retransmet ensuite son réseau de neurones sur ces mémoires et est ensuite projeté contre le best_player. S'il gagne, le réseau de neurones à l'intérieur de best_player est commuté pour le réseau de neurones à l'intérieur de current_player et la boucle recommence.

agent.py

Ceci contient la classe Agent (un joueur dans le jeu). Chaque joueur est initialisé avec son propre réseau de neurones et son arbre de recherche de Monte Carlo.

La méthode de simulation exécute le processus de recherche d’arbres de Monte-Carlo. Plus précisément, l'agent se déplace vers un nœud feuille de l'arborescence, évalue le nœud avec son réseau de neurones, puis renvoie la valeur du nœud dans l'arborescence.

La méthode act répète la simulation plusieurs fois pour comprendre quel déplacement de la position actuelle est le plus favorable. Il renvoie ensuite l'action choisie au jeu, pour déclencher le déplacement.

La méthode de lecture rejoue le réseau de neurones en utilisant les souvenirs des jeux précédents.

model.py

Un échantillon de la construction du réseau convolutionnel résiduel à l'aide de Keras

Ce fichier contient la classe Residual_CNN, qui définit comment créer une instance du réseau de neurones.

Il utilise une version condensée de l’architecture de réseau neuronal du papier AlphaGoZero, c’est-à-dire une couche convolutive, suivie de nombreuses couches résiduelles, puis se divise en une tête de valeur et de stratégie.

La profondeur et le nombre de filtres de convolution peuvent être spécifiés dans le fichier de configuration.

La bibliothèque Keras est utilisée pour construire le réseau, avec un backend de Tensorflow.

Pour afficher les filtres de convolution individuels et les couches densément connectées du réseau de neurones, exécutez les opérations suivantes dans le bloc-notes run.ipynb:

current_player.model.viewLayers ()
Filtres de convolution du réseau de neurones

SCTM.py

Il contient les classes Node, Edge et MCTS, qui constituent un arbre de recherche Monte Carlo.

La classe MCTS contient les méthodes moveToLeaf et backFill mentionnées précédemment, et des instances de la classe Edge stockent les statistiques relatives à chaque déplacement potentiel.

config.py

C'est ici que vous définissez les paramètres clés qui influencent l'algorithme.

L'ajustement de ces variables affectera le temps d'exécution, la précision du réseau neuronal et le succès général de l'algorithme. Les paramètres ci-dessus produisent un lecteur Connect4 de haute qualité, mais prennent beaucoup de temps pour le faire. Pour accélérer l’algorithme, essayez plutôt les paramètres suivants.

funcs.py

Contient les fonctions playMatches et playMatchesBetweenVersions qui jouent les correspondances entre deux agents.

Pour jouer contre votre création, exécutez le code suivant (il se trouve également dans le bloc-notes run.ipynb)

à partir de l'importation du jeu
from funcs import playMatchesBetweenVersions
importer des enregistreurs en tant que lg
env = Game ()
playMatchesBetweenVersions (
env
, 1 # le numéro de version du lecteur où se trouve le lecteur
, -1 # le numéro de version du premier joueur (-1 pour l'homme)
, 12 # le numéro de version du second joueur (-1 pour l'homme)
, 10 # combien de jeux à jouer
, lg.logger_tourney # où se connecter au jeu
, 0 # quel joueur aller en premier - 0 pour le hasard
)

initialise.py

Lorsque vous exécutez l'algorithme, tous les fichiers de modèle et de mémoire sont enregistrés dans le dossier d'exécution, dans le répertoire racine.

Pour redémarrer l'algorithme à partir de ce point de contrôle ultérieurement, transférez le dossier d'analyse vers le dossier run_archive en attachant un numéro d'exécution au nom du dossier. Ensuite, entrez le numéro d’exécution, le numéro de version du modèle et le numéro de version de la mémoire dans le fichier initialise.py, correspondant à l’emplacement des fichiers appropriés dans le dossier run_archive. L'exécution de l'algorithme comme d'habitude commencera alors à partir de ce point de contrôle.

mémoire.py

Une instance de la classe Memory stocke les mémoires des jeux précédents, que l'algorithme utilise pour reconvertir le réseau neuronal du current_player.

perte.py

Ce fichier contient une fonction de perte personnalisée, qui masque les prédictions des déplacements illégaux avant de passer à la fonction de perte d'entropie croisée.

settings.py

Les emplacements des dossiers run et run_archive.

loggers.py

Les fichiers journaux sont enregistrés dans le dossier du journal à l'intérieur du dossier d'exécution.

Pour activer la journalisation, définissez les valeurs des variables logger_disabled sur False dans ce fichier.

Consulter les fichiers journaux vous aidera à comprendre le fonctionnement de l’algorithme et à voir à l’intérieur de son "esprit". Par exemple, voici un exemple du fichier logger.mcts.

Sortie du fichier logger.mcts

De même, dans le fichier logger.tourney, vous pouvez voir les probabilités attachées à chaque déplacement, pendant la phase d’évaluation:

Sortie du fichier logger.tourney

Résultats

La formation sur quelques jours produit le tableau suivant des pertes par rapport au nombre d’itérations de mini-lots:

Perte par rapport au numéro d'itération du mini-lot

La ligne supérieure représente l'erreur dans l'en-tête de stratégie (l'entropie croisée des probabilités de déplacement du SCTM par rapport à la sortie du réseau de neurones). La ligne du bas est l'erreur dans l'en-tête de valeur (l'erreur quadratique moyenne entre la valeur de jeu réelle et la valeur prédite par le réseau de neurones). La ligne médiane est une moyenne des deux.

Il est clair que le réseau de neurones est de mieux en mieux à prédire la valeur de chaque état de jeu et des prochains mouvements probables. Pour montrer comment cela se traduit de plus en plus fort, j'ai couru une ligue entre 17 joueurs, allant de la 1ère itération du réseau de neurones à la 49ème. Chaque couple a joué deux fois, les deux joueurs ayant eu la chance de jouer en premier.

Voici le classement final:

Il est clair que les versions les plus récentes du réseau de neurones sont supérieures aux versions précédentes, remportant la plupart de leurs jeux. Il semble également que l’apprentissage n’ait pas encore été saturé - avec du temps d’entraînement supplémentaire, les joueurs continueraient à se renforcer, apprenant des stratégies de plus en plus complexes.

Par exemple, une stratégie claire que le réseau de neurones a privilégiée au fil du temps consiste à s’emparer de la colonne centrale plus tôt. Observez la différence entre la première version de l’algorithme et dites, par exemple, la 30ème version:

1ère version du réseau de neurones

30ème version du réseau de neurones

C'est une bonne stratégie car de nombreuses lignes requièrent la colonne du centre - l'affirmer tôt garantit que votre adversaire ne pourra pas en tirer parti. Ceci a été appris par le réseau de neurones, sans aucune intervention humaine.

Apprendre un jeu différent

Il existe un fichier game.py pour un jeu appelé "Metasquares" dans le dossier des jeux. Cela implique de placer les marqueurs X et O dans une grille pour essayer de former des carrés de différentes tailles. Les plus grands carrés marquent plus de points que les plus petits et le joueur qui a le plus de points lorsque la grille est pleine gagne.

Si vous changez le fichier game.py Connect4 pour le fichier game.py Metasquares, le même algorithme apprendra comment jouer à Metasquares.

Résumé

J'espère que vous trouverez cet article utile. Si vous trouvez des fautes de frappe ou si vous avez des questions à propos de quelque chose dans le code ou l'article, dites-le-moi dans les commentaires ci-dessous et je vous répondrai dès que possible.

Si vous souhaitez en savoir plus sur la manière dont notre société, Applied Data Science développe des solutions innovantes en science des données pour les entreprises, n'hésitez pas à entrer en contact via notre site Web ou directement via LinkedIn.

… Et si vous aimez cela, n'hésitez pas à laisser quelques applaudissements chaleureux :)

Applied Data Science est une société de conseil basée à Londres qui implémente des solutions de science des données de bout en bout pour les entreprises, offrant une valeur mesurable. Si vous souhaitez utiliser davantage vos données, parlons-en.