[PYTHON] Faisons l'IA d'Othello avec Chainer-Part 2-

introduction

Cet article est une suite de "Création d'Othello AI avec Chainer-Part 1-". Nous espérons que vous aurez lu la première partie avant de lire cet article.

• Partie 1

• Conversion des données des enseignants

• Conception MLP

• Formation et stockage des modèles

• Partie 2 (cet article)

• Implémentation dans les jeux Othello

• Vérifiez s'il est jouable (pouvez-vous jouer au jeu sans déroger aux règles)

• Si vous trouvez qu'il n'est pas jouable ici, revenez à la création du modèle MLP

Donc, en utilisant le modèle entraîné créé dans la première partie, j'ai implémenté l'IA en utilisant le modèle MLP dans le jeu Othello. Pour l'application de jeu Othello, utilisez celle créée dans "Faisons Othello avec wxPython". Le code source et les modèles entraînés de l'application de jeu Othello sont répertoriés sur GitHub, veuillez donc les récupérer à partir de là.

Description de l'application de jeu Othello

Ceci est une application créée avec wxPython. Il nécessite wxPython pour fonctionner. Veuillez consulter ici pour la méthode d'installation. La méthode de démarrage est la suivante.

$ python reversi.py

Je vais expliquer brièvement l'écran. Spécifiez le modèle pour l'IA par MLP dans "Paramètre du modèle MLP" à l'extrême droite. Spécifiez le modèle pour le premier coup (noir) dans «pour le noir» et le modèle pour le deuxième coup (blanc) dans «pour le blanc». De même, spécifiez l'IA de l'ordinateur dans le "Réglage de l'IA de l'ordinateur" à l'extrémité droite. Les détails de l'IA seront décrits plus loin. Dans la zone vide au centre, le score est affiché au fur et à mesure que le jeu progresse. Réglez le type de jeu en «Mode jeu» en bas au centre et démarrez le jeu avec le bouton «START».

• Man vs Man
• Combat humain à humain. Clic gauche pour placer la pierre. Le premier mouvement est noir.
• Man vs Computer A
• Humain vs ordinateur A. Les humains sont les premiers (noirs). Computer AI sera celui défini comme Computer A dans "Computer AI setting".
• Computer A vs Man
• Ordinateur A vs humain. L'ordinateur A est le premier (noir).
• Computer A vs Computer B
• Rivaliser entre les ordinateurs.

"SCORE" en bas au centre est le nombre actuel de pierres dans le premier (noir) et le deuxième (blanc). Entrez le nombre de boucles dans la zone de texte en bas au centre et appuyez sur le bouton "Comp vs Comp Loop" pour lire l'ordinateur A et l'ordinateur B pour le nombre spécifié de fois dans une ligne. (Pour le moment, n'utilisez pas le bouton "START") À la fin de la boucle, le nombre de victoires pour l'ordinateur A et l'ordinateur B sera affiché. DRAW est le nombre de tirages.

Cette application Othello vous permet non seulement de jouer des batailles régulières, mais possède également les fonctionnalités suivantes.

1. Vous pouvez sélectionner Computer AI. (Pour plus d'informations sur l'IA autre que MLP, cliquez ici](http://qiita.com/kanlkan/items/cf902964b02179d73639))
   • MLP

• IA utilisant un modèle MLP entraîné. C'est l'objet d'une vérification.
  • 1st Gain Max
• IA qui définit une valeur d'évaluation sur le plateau et la place dans un endroit où la valeur d'évaluation totale des pierres pouvant être prises par soi-même est élevée.
  • Min Max 3
• AI qui lit 3 fois à l'avance en utilisant la méthode Min-Max. Mais très faible. Peut-être que quelque chose ne va pas.
  • Random
• AI qui le place au hasard dans un endroit où il peut être placé.

1. Si AI utilisant le modèle MLP est sélectionné et AI sélectionne un mouvement qui s'écarte des règles, "* Déplacement illégal! ... *" est émis vers la sortie d'erreur standard. Les types sont les suivants. ** Si un mouvement illégal se produit, la main de l'ordinateur sera placée à la première place trouvée dans la pierre, si elle peut être placée, et s'il est nécessaire de passer, passez-la et continuez la partie. Masu (Fail Safe). ** **
   • Cannot put stone but AI cannot select 'PASS'.

• Je ne pouvais pas sélectionner PASS même si je n'avais pas d'endroit pour poser des pierres.
  • Cannot 'PASS' this turn but AI selected it.
• J'ai choisi PASS même si je ne pouvais pas passer (il y avait un endroit pour le mettre).
  • Cannot put stone at AI selected postion.
• Vous avez sélectionné un endroit où vous ne pouvez pas placer de pierres.

1. Vous pouvez compter les victoires et les pertes en jouant plusieurs batailles entre des IA informatiques d'affilée.

• Les première et deuxième attaques de chaque IA sont décidées au hasard.
• Enregistrez le score de la bataille entre les IA sous "* record.log *".
• Ce score peut être lu par "* build_mlp.py *".

Vérifier l'IA à l'aide du modèle MLP

Passons maintenant à vérifier s'il est jouable. Je veux faire une IA forte si possible. Par conséquent, le modèle entraîné en utilisant uniquement le score de jeu du premier jeu gagnant (noir) (* model_black_win.npz ) et le modèle formé en utilisant uniquement le score de jeu du deuxième joueur (blanc) ( model_white_win.npz) Jouons contre un humain (moi) en utilisant *). Hmmmm. .. .. ** Mumu **. ** Mouvement illégal! Il est sorti ... ** Ce n'était pas aussi facile que lors de l'organisation de trois yeux. Cependant, il est toujours conforme aux attentes. Tout d'abord, examinons les types de mouvements illégaux qui apparaissent et leur fréquence. Le soleil se couche lorsque vous jouez contre vous-même, alors jouons les uns contre les autres. Je jouerai contre MLP et Random. Mouvement illégal! S'est produit 7027 fois en 1000 batailles. La répartition des types de mouvement illégal qui s'est produit est la suivante.

Calculez grossièrement. En supposant qu'aucune passe n'est générée dans une partie et que le plateau ne peut pas être réglé tant qu'il n'est pas rempli, 60 coups seront effectués jusqu'à ce que le plateau soit rempli et réglé. Un joueur réussit 30 coups. 30 000 coups en 1000 batailles. Ainsi, puisqu'il est 7027/30000, on peut estimer grossièrement que 23,4% des cas sont frauduleux.

80% des jeux se jouent selon les règles, je crains donc de changer la configuration MLP ... Tout d'abord, je ferai ce que je peux penser sans changer la configuration de MLP.

Le festival try & error a commencé.

Réessayer 1: essayez d'utiliser le score de tous les matchs, pas seulement le score du match gagnant

Pour créer une IA forte, je vais la mettre de côté et donner la priorité au respect des règles. Nous allons essayer d'augmenter la variété des modèles en apprenant non seulement les jeux qui y ont gagné mais aussi les jeux qui ont perdu. Définissez "* model_black.npz " pour le premier mouvement (noir) et " model_white.npz *" pour le deuxième mouvement (blanc) comme MLP AI. Ces modèles sont des modèles créés avec les commandes suivantes.

$ python build_mlp.py Othello.01e4.ggf black
$ mv reversi_model.npz model_black.npz
$ python build_mlp.py Othello.01e4.ggf white
$ mv reversi_model.npz model_white.npz

Maintenant, jouons les ordinateurs les uns contre les autres comme avant. MLP vs revanche aléatoire. Mouvement illégal! S'est produit 5720 fois en 1000 batailles. La répartition est la suivante.

Puisqu'il est 5720/30000, il est illégal à un taux de 19,1%. Il semble que l'avenir soit encore long, mais il est moins qu'avant. C'est une bonne tendance.

Réessayer 2: essayez d'augmenter le nombre d'époques pour vous entraîner de 1000 à 3000

C'est assez vaincu, mais si vous vous entraînez plus souvent, cela fonctionnera. J'ai modifié "* build_mlp.py *" afin que batch_size et max epoch count puissent être spécifiés comme arguments, et recréé le modèle avec batch_size = 100 et max_epoch_count = 3000.

$ python build_mlp.py Othello.01e4.ggf black 100 3000
$ mv reversi_model.npz model_epoch-3000_black.npz
$ python build_mlp.py Othello.01e4.ggf white 100 3000
$ mv reversi_model.npz model_epoch-3000_white.npz

D'ailleurs, dans mon environnement, cet apprentissage a pris 5 heures + 5 heures = 10 heures ... J'ai peur de n'avoir qu'un environnement Linux sur VirtualBox ...

Laissez les ordinateurs jouer les uns contre les autres avec ces modèles. MLP contre 1000 batailles aléatoires.

Puisqu'il s'agit de 5966/30000, 19,9% du temps c'est frauduleux. Cela ne change pas grand-chose. Même si vous augmentez l'Époque à 1000 ou plus, il semble que l'apprentissage ne se poursuivra plus. En fait, même si vous n'essayez pas avec Epoch réglé sur 3000, préparez séparément environ 1000 données de test similaires aux données de l'enseignant et prenez la corrélation Epoch-Précision (courbe d'apprentissage) lors de l'exécution de "* build_mlp.py *". Si vous le regardez, vous pouvez voir à quel point Epoch est peu susceptible de faire progresser l'apprentissage.

Réessayer 3: effectuez 10000 fois MLP vs aléatoire et utilisez le modèle formé sur ce score

Même si les données des enseignants sont conçues, elles ne fonctionnent pas bien, je vais donc essayer une approche différente. Configurez MLP AI en utilisant "* model_black.npz ", " model_white.npz " et jouez les uns contre les autres en MLP vs Random (10000 batailles cette fois). J'essaierai de m'entraîner à nouveau avec ce score. L'intention est que je pense qu'il est possible d'en apprendre davantage sur les modèles dans lesquels MLP AI n'est pas bon en utilisant un syllabaire qui donne la bonne réponse avec la fonction Fail Safe pour les modèles pour lesquels MLP AI n'est pas bon. Parce que c'est. Tout d'abord, jouons à 10000 MLP contre Random. Un fichier de partition appelé " record.log " sera sauvegardé, renommez-le donc en " mlp_vs_random_10000_01.log *". Lisez ce fichier journal et recréez le modèle.

$ python build_mlp.py mlp_vs_random_10000_01.log black 100 1000
$ mv reversi_model.npz model_mlp_vs_random_black_01.npz
$ python build_mlp.py mlp_vs_random_10000_01.log white 100 1000
$ mv reversi_model.npz model_mlp_vs_random_white_01.npz

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_mlp_vs_random_black_01.npz, model_mlp_vs_random_white_01.npz *). Mouvement illégal! S'est produit 2794 fois en 1000 matchs. La répartition est la suivante.

Puisqu'il est 2794/30000, il est illégal à un taux de 9,3%. Ça m'a l'air bien! C'est environ la moitié! Maintenant, faisons de notre mieux à partir d'ici.

Cette méthode semble fonctionner, alors essayez à nouveau les mêmes étapes. Utilisez * model_mlp_vs_random_black_01.npz, model_mlp_vs_random_white_01.npz * pour jouer 10000 fois dans MLP vs Random, remplacez "* record.log " par " mlp_vs_random_10000_02.log *" et recréez le modèle avec ce journal. Je vais.

$ python build_mlp.py mlp_vs_random_10000_02.log black 100 1000
$ mv reversi_model.npz model_mlp_vs_random_black_02.npz
$ python build_mlp.py mlp_vs_random_10000_02.log white 100 1000
$ mv reversi_model.npz model_mlp_vs_random_white_02.npz

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_mlp_vs_random_black_02.npz, model_mlp_vs_random_white_02.npz *). Mouvement illégal! S'est produit 2561 fois en 1000 batailles. La répartition est la suivante.

Puisqu'il est 2399/30000, 8,0% des cas sont frauduleux. Hmmm ... devrait-il être considéré comme une légère baisse? Une fois, cette méthode est arrêtée ici.

Réessayer 4: effectuez 10000 fois MLP vs Random, combinez le score avec Othell0.01e4.ggf et utilisez le modèle entraîné.

$cat Othello.01e4 mlp_random_10000_01.log > 01e4_mlp_randomA_10000_01.ggf
$ python build_mlp.py 01e4_mlp_randomA_10000_01.ggf
 black 100 1000
$ mv reversi_model.npz model_01e4_mlp_vs_random_black_02.npz
$ python build_mlp.py 01e4_mlp_randomA_10000_01.ggf
 white 100 1000
$ mv reversi_model.npz model_01e4_mlp_vs_random_white_02.npz

Comme mentionné ci-dessus, entraînons-nous avec le syllabaire existant "* Othello.01e4.ggf " et le syllabaire créé à l'étape précédente " mlp_random_10000_01.log *". Je pensais que la performance serait améliorée car le score serait plus diversifié et inclurait une main qui deviendrait un coup illégal.

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_01e4_mlp_vs_random_black.npz, model_01e4_mlp_vs_random_white.npz *). Mouvement illégal! S'est produit 3325 fois en 1000 batailles. La répartition est la suivante.

Puisqu'il est 3325/30000, nous faisons des actions frauduleuses à un taux de 11,1%. Eh bien, le résultat n'est pas très différent de Retry 3. Pardon.

Résumé intermédiaire

Cette semaine, je vais le résumer ici.

• Le simple fait de lire la partition du premier modèle n'en fait pas une IA jouable
• L'IA qui ne lit que le score gagnant en noir et blanc est plus susceptible de faire une erreur.
• L'IA de MLP doit être équipée d'une fonction qui peut au moins modifier la main qui peut continuer le jeu en tant que Fail Safe si la mauvaise main est sélectionnée.
• Si vous définissez Fail Safe dans AI dans MLP, acquérez un grand nombre de portées avec MLP vs Random, et entraînez-vous à nouveau avec ces portées, vous pouvez réduire le risque d'erreur.

Est-ce un tel endroit? À l'heure actuelle, la probabilité de sélectionner un mouvement illégal a été réduite à 8,0%, donc l'IA avec Fail Safe sera le résultat au point médian. Eh bien, c'est peut-être le résultat final, mais je suis un peu déçu, donc à partir de la semaine prochaine, je jouerai avec les paramètres du modèle MLP. J'ajouterai plus à cet article sur les essais futurs. Si vous êtes intéressé par le développement, veuillez le regarder.

Dans cette étude, dans mon environnement, c'est un gros goulot d'étranglement qu'il faut plusieurs heures pour former le modèle à partir de la partition à chaque fois ... Si vous pouvez utiliser le GPU, je pense que vous pouvez le faire un peu plus facilement, il serait donc intéressant de réécrire "* build_mlp.py *" pour supporter le GPU et essayer diverses choses.

** ↓↓↓↓↓ 2016/08/14 mise à jour ↓↓↓↓↓ **

Confirmation de la courbe d'apprentissage

Mise à jour de "* bulb_mlp.py *" pour afficher la courbe d'apprentissage. Réservez 1000 échantillons à la fin des données en tant que données de test (Validation) (ces 1000 échantillons ne sont pas utilisés pour la formation), et pour le taux de réponse correct (principal / précision) dans les données de formation à chaque époque et les données de test inconnues du modèle. Le taux de réponse correct (validation / principal / précision) est affiché. Vous pouvez maintenant dessiner la courbe d'apprentissage. Eh bien, c'est une histoire que vous devriez enfin faire depuis le début ...

Tout d'abord, la courbe d'entraînement dans le premier modèle est affichée.

À 1000 Epoch, principal / précision est saturé à environ 0,45. On peut juger qu'essayer de changer l'Époque effectuée lors de la nouvelle tentative 2 de 1000 à 3000 semble être inefficace. Au fait, le taux de réponse correcte de 0,45 = 45% n'est-il pas bas? Vous pensez peut-être, mais comme nous utilisons le score réel, il y a plusieurs mouvements pour répondre à une certaine condition du tableau, il semble donc que le taux de réponse correct ne soit pas si élevé.

Ensuite, la courbe d'apprentissage lorsque le nombre de neurones dans la couche cachée (h1, h2) est augmenté de 100 à 200 est affichée.

C'est la même chose qu'il converge presque vers 1000 Epoch. L'augmentation du nombre de neurones augmente le taux de réponse correct (principal / précision) des données d'entraînement, mais la valeur de validation / principal / précision, qui est le taux de réponse correct pour les entrées inconnues, est presque la même que lorsque le nombre de neurones est de 100. Cela signifie ... je ne pense pas que je peux me conformer aux règles même si je passe de 100 à 200 neurones ... Mais pour le moment, je vais le vérifier lors d'une nouvelle tentative 5.

Réessayer 5: augmenter les neurones h1 et h2 de 100 à 200

Je pensais que l'augmentation du nombre de neurones augmenterait l'effet d'entraînement sur le score et permettrait de respecter les règles. Modifiez la définition de la classe MLP dans "* build_mlp.py *".

...
class MLP(Chain):
    def __init__(self):
        super(MLP, self).__init__(
                l1=L.Linear(64,200)
                l2=L.Linear(200,200)
                l3=L.Linear(200,65)
        )
...

Après les modifications, créez un modèle entraîné.

$ python build_mlp.py Othelo.01e4.ggf black 100 1000
$ mv reversi_model.npz model_neuron-200_black.npz
$ python build_mlp.py Othelo.01e4.ggf white 100 1000
$ mv reversi_model.npz model_neuron-200_white.npz

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_neuron-200_black.npz, model_neuron-200_white.npz ). (La définition de la classe MLP dans " reversi.py *" doit également être modifiée comme décrit ci-dessus) Mouvement illégal! S'est produit 10778 fois en 1000 batailles. La répartition est la suivante.

Puisqu'il est 10997/30000, nous faisons des actions frauduleuses à un taux de 36,7%. Cela empire ... peut-être que cela correspond trop aux données d'entraînement.

Réessayer 6: augmenter l'échantillon d'entraînement d'environ 3 fois

Connectons non seulement Othello.01e4.ggf mais aussi Othello.02e4.ggf et Othello.03e4.ggf pour lire le score d'échecs, et faisons-en environ 3 fois plus pour apprendre plus de motifs différents.

$ cat Othello.01e4.ggf Othello.02e4.ggf Othello.03e4.ggf > Othello.01-03e4.ggf
$ python build_mlp.py Ohtello.01-03e4.ggf black 100 1000
$ mv reversi_model.npz model_01-03e4_black.npz 
$ python build_mlp.py Ohtello.01-03e4.ggf white 100 1000
$ mv reversi_model.npz model_01-03e4_white.npz

La courbe d'apprentissage est la suivante. La validation / main / précision est passée de 0,3 à 0,35 par rapport au cas où le score n'est que Othello.01e4.ggf. Pouvez-vous vous attendre un peu?

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_01-03e4_black.npz, model_01-03e4_white.npz *). Mouvement illégal! S'est produit 5284 fois en 1000 matchs. La répartition est la suivante.

Puisqu'il est 5284/30000, il est illégal à un taux de 17,6%. Ce n'est pas très différent du cas où seul Othello.01e4.ggf est utilisé pour le score du jeu (19,1%). Ça devient assez compliqué ...

Réessayer 7: Ajouter des informations de «lieu» à l'entrée MLP (état de la carte)

Cette fois, je vais changer la façon de penser et essayer de modifier l'entrée MLP elle-même. Plus précisément, en plus de «0»: aucun, «1»: noir, «2»: blanc et «3»: place pour placer les informations de la carte à donner en entrée. Par exemple. X1 est l'état X0 dans le cas du virage noir, avec une place pour le mettre ajouté.

X0 = [[0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,2,1,0,0,0],\
      [0,0,1,2,2,2,2,0],\
      [0,0,0,1,2,2,0,0],\
      [0,0,0,0,1,2,0,0],\
      [0,0,0,0,0,0,0,0]]

X1 = [[0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,3,3,0,0,0],\
      [0,0,3,2,1,3,0,3],\
      [0,0,1,2,2,2,2,3],\
      [0,0,3,1,2,2,3,0],\
      [0,0,0,0,1,2,3,0],\
      [0,0,0,0,0,0,0,0]]

En faisant cela, j'ai pensé qu'une IA conforme aux règles pouvait être créée. Il semble y avoir un tsukkomi disant "Je vous dis presque les règles!", Mais l'hypothèse que l'état de la carte est utilisé comme entrée et que le coup suivant est obtenu comme sortie n'a pas changé. (Une excuse assez douloureuse ...) "* Build_mlp.py *" modifié pour spécifier s'il faut ajouter un emplacement pour le placer. Si True est ajouté à la fin de la commande, l'endroit où il peut être placé sera ajouté à la carte d'entrée en tant que «3».

$ pythohn build_mlp.py Othello.01e4.ggf black 100 1000 True
$ mv reversi_model.npz model_black_puttable_mark.npz 
$ pythohn build_mlp.py Othello.01e4.ggf white 100 1000 True
$ mv reversi_model.npz model_white_puttable_mark.npz 

La courbe d'apprentissage est la suivante.

Il a la validation / principale / précision la plus élevée à ce jour et converge vers 0,4.

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_black_puttable_mark.npz, model_white_puttable_mark.npz ). Correction de " reversi.py " pour prendre en charge ces modèles. Si le nom du modèle MLP spécifié contient " puttable_mark *", il correspond à l'entrée représentée par "3" où il peut être placé.

Mouvement illégal! S'est produit 207 fois en 1000 batailles. La répartition est la suivante.

Puisqu'il est 207/30000, nous faisons quelque chose d'illégal à un taux de 0,7%. Quel 1% ou moins! C'est une amélioration spectaculaire.

Résumé final

Je vais résumer ce qui précède.

• Le simple fait de lire la partition du premier modèle n'en fait pas une IA jouable
• L'IA qui ne lit que le score gagnant en noir et blanc est plus susceptible de faire une erreur.
• L'IA de MLP doit être équipée d'une fonction qui peut au moins modifier la main qui peut continuer le jeu en tant que Fail Safe si la mauvaise main est sélectionnée.
• Si vous définissez Fail Safe dans AI dans MLP, acquérez un grand nombre de portées avec MLP vs Random, et entraînez-vous à nouveau avec ces portées, vous pouvez réduire le risque d'erreur.
• L'augmentation du nombre de neurones MLP ne peut pas réduire (plutôt aggraver) la probabilité de faire une erreur
• L'augmentation des échantillons de formation MLP ne réduit pas le risque de faire une erreur
• Ajouter «place à mettre» comme information à l'état du tableau, qui est l'entrée, peut considérablement améliorer la possibilité de faire une erreur.

En tant qu'IA qui fonctionne correctement, est-ce celui avec "Fail Safe" ajouté à celui avec "Place" ajouté comme "3" dans l'état de la carte? C'est peut-être un peu bâclé, mais j'ai pu créer une IA décente.

À l'heure actuelle, la force de l'IA ne dépend que du score. Après avoir créé l'IA de base par la méthode ci-dessus, elle sera renforcée en utilisant le renforcement de l'apprentissage, etc. J'ignore totalement l'apprentissage par renforcement, alors j'essaierai après mes études.

Merci pour votre considération. C'était pauvre.