Créer une I.A qui apprend toute seule à jouer au morpion (Explication + Code source inclus)

Créer une I.A qui apprend toute seule à jouer au morpion (Explication + Code source inclus)

Dans ce second post sur comment créer une I.A, j’ai décidé de passé directement à la pratique avec vous. C’est pour cela que nous allons créer une I.A qui apprend d’elle même à jouer au morpion. Même si nous la créons exclusivement pour jouer au morpion les notions vues durant ce mini-cours sont applicables à tout type de jeu.


Pour ce faire, on va utiliser un concept bien connu en intelligence artificielle qui est l’apprentissage par renforcement et la classification.


L’apprentissage par renforcement consiste à créer une I.A qui ne sait rien faire du tout au départ, puis lui faire expérimenter une situation où elle doit prendre une décision. Si la décision qu’elle a prise est bonne, elle est récompensée, sinon elle est punie.

La classification comme je l’ai dit dans mon précédent article consiste à entraîner une I.A avec des données auxquels un résultat a été associé.



Création du jeu du Morpion


Dans un premier temps, nous allons créer le jeu du morpion et pour cela, nous allons utiliser le langage de programmation python.

Pour ceux qui n’ont pas encore installé python, je vous invite à l’installer, j’explique la procédure à la fin de ce post.


Tout d’abord, je souhaiterais que vous vérifier que python est bien de vos variable d’environnement pour cela appuyer sur la touche window puis tapez variable et cliquez sur modifier les variable d’environnement. Une fênêtre s’ouvre cliquez sur variable d’environnement dans cette fenêtre


Cliquez ensuite sur modifier, et assurez-vous que le chemin menant au dossier contenant l’exécutable python.exe est bien dans les variables d’environnement si ce n’est pas le cas rajoutez le en utilisant le bouton “Nouveau”.


Si c’est le cas parfait.


Nous allons de ce pas installer scikit-learn :


Pour cela il faut ouvrir le shell windows et tapez

python -m pip install scikit-learn


Scikit-learn est une bibliothèque qui permet d’utiliser sans grand effort les algorithmes les plus connus de machine learning. Elle présente de nombreux avantages : premièrement, c’est une bibliothèque très diversifiée les algorithmes de machine learning les plus populaires (arbre de décision, SVM, réseau de neurones, etc...) y sont implémentés dans des versions optimisées. Deuxièmement, elle dispose d’une documentation très claire et concise illustrée par de nombreux exemples de codes python. Enfin, elle a pour but d’être une bibliothèque très ludique et accessible à tous, ce qui explique sa popularité. Je qualifierais donc scikit-learn de bibliothèque permettant à n'importe qu'elle développeur lambda de devenir un vrai expert en machine learning sans pour autant qu'il n'ait besoin d'un background poussé sur cette discipline.



Dans un premier temps, il faut importer les bibliothèque et fonction dont python aura besoin pour la création du morpion et de l’I.A :


Une fois toutes les bibliothèques importées, nous créons une classe morpion, dans cette classe il y aura une fonction init qui initialisera l’ensemble des paramètres du jeu,une fonction jeu qui contiendra la boucle principale du jeu, une fonction afficher plateau qui permettra d’afficher le plateau de jeu et enfin une fonction jouer qui permettra au joueur de choisir puis de jouer son mouvement.



Dans la fonction __init__, le plateau de jeu est initialisé avec des “-”, le joueur 1 est initialisé avec une croix et le joueur 2 est initialisé avec un rond. Cela signifie que partout sur le plateau ou il y des tirets il n’y a personne qui a joué, partout ou il y a des croix cela signifie que le joueur 1 a joué et partout où il y a des ronds, cela signifie que le joueur 2 a joué.



La fonction jouer, commence par lire au clavier l’abscisse puis l’ordonnée de la position ou le joueur courant souhaite jouer, puis écrit le signe du joueur sur le plateau.



La fonction afficher_plateau parcourt le plateau et l’affiche en veillant à bien séparer chaque signe par deux barre “|”



Test_fin_jeu va vérifier si l’un des deux joueurs a gagné ou s’il n’y a pas égalité, pour cela elle va vérifier qu’il n’y a pas 3 fois le même signe aligné ni en horizontal, ni en vertical, ni en diagonal puis elle va vérifier qu’il reste des signes “-” sur le plateau.



Enfin pour finir, la fonction jeu, va utiliser lancer le game, en affichant premièrement le tableau, puis en appelant les fonctions que j’ai montrées plus haut et tant que l'un des deux joueurs n’aura pas gagné, elle va les faire jouer chacun leur tour, puis afficher le nouveau plateau et tester que le jeu n’est pas fini. S’il est fini on sort de la fonction en revoyant le signe du joueur gagnant ou en renvoyant égalité si c’est une égalité.



Créer l’IA qui apprend d’elle même à jouer

Voili voilou ! ;-D maintenant que le morpion est près nous pouvons enfin créer l’IA qui s’amusera à apprendre à jouer et qui deviendra un bon joueur à la fin.

Pour ce faire, nous allons modifier la fonction d’initialisation de la classe morpion et rajouter sept nouvelles fonctions, ai_jeu, convert_plateau, train_ai_jeu,générateur_de_mouvement,train_ai_player, entraineur_ai_joue et ai_player_joue,

Vous devriez donc obtenir le schéma de classe ci-dessous :



Dans la fonction init, nous avons rajouté trois variables la première est self.base_de_jeu et self.base_resultat_jeu qui contiendront respectivement l’ensemble des parties passées et leurs résultats. Conserver ces données nous permettra d’entraîner l’algorithme de classification que nous avons choisi.

Il y a ensuite self.clf, il s’agit du classifieur qui nous permettra de générer l’intelligence artificielle du morpion. Bien que j’aurais pu choisir un réseau de neurones, j’ai choisi un arbre de décision, car il est plus facile à configurer et plus efficace sur ce problème.






La fonction initialiser_plateau, nous permettra de réinitialiser le plateau à chaque fin de partie.




Le code de la fonction train_ai_jeu fait jouer l’IA 10 fois 10000 partie contre l’entraîneur, et à l’issue de chacune des 10000 parties, le score de chacun des joueurs est affiché et le comportement de l’IA est actualisé.




La fonction generateur_de_mouvement, va retourner tous les mouvements possibles pour le joueur passé en paramètre. Pour cela, elle va tester chaque case du plateau afin de savoir si elle est vide.




La fonction update_ai_player, va actualiser le comportement de l’IA, tous simplement en entraînant le classifieur choisi clf via la fonction fit sur l’ensemble des parties qui ont été jouées depuis le début.



L’entraineur de l’IA va choisir aléatoirement un mouvement parmi tous les mouvements possibles et les jouer.



Enfin, c’est au tour de l’IA de jouer. Pour ce faire, elle va d’abord évaluer l’ensemble des mouvements possible via la fonction predict_proba qui prédira la probabilité que l’IA gagne pour chaque mouvement. Le mouvement obtenant la plus grande probabilité de victoire est alors joué.



Pour finir, pour tester, l’ensemble du code il suffit de créer une instance de la classe morpion et d’appeler train_ai_jeu pour que l’IA se mette à apprendre d’elle même.



Résultat :


Arbre de décision :



En utilisant le RandomForest où encore le perceptron multicouche les scores obtenus comme on peut le constater dans les images ci-dessous sont bien moins intéressants. Le modèle le plus adapté à ce problème est donc l’arbre de décision.


RandomForest 



Perceptron multi-couche


Pour ceux qui veulent aller plus loin et devenir de vrai expert dans l’intelligence artificielle je vous propose ma formation : créez votre propre intelligence artificielle de A à Z en partant de zéro.


. Creative Commons License
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 2.0 Generic License.