Kaissa XXI Principes et programmation d`un jeu d`échecs

Kaissa XXI
Principes et programmation d'un jeu d'échecs
Emmanuel CAPLIEZ
[email protected]
22 mars 2010
Table des matières
1 Présentation du projet
2
2 Cahier des charges
3
2.1
Modules obligatoires
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.2
Modules optionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3 Supports fournis
4
3.1
Règles du jeu d'Echecs . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
3.2
Base logicielle de Kaissa XXI
. . . . . . . . . . . . . . . . . . . . . . . .
4
3.3
Code : :Blocks
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
4 Heuristiques et algorithmes étudiés
5
4.1
Heuristique d'évaluation de position
. . . . . . . . . . . . . . . . . . . .
5
4.2
Algorithme MiniMax . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
4.3
Algorithme Alpha-Beta
8
. . . . . . . . . . . . . . . . . . . . . . . . . . .
Avant-Propos
Le projet Kaissa XXI constitue l'un des sujets proposés aux étudiants de
première année de l'Ecole Nationale Supérieure de Techniques Avancées
1 au
titre du cours IN104 : Projet informatique. Ce document est destiné à fournir
la matière nécessaire à la réalisation ce projet. Dans un souci d'amélioration
continue, toute remarque sera la bienvenue.
Côté anecdote, le nom de ce projet fait référence au programme d'échecs
Kaissa développé en URSS dans les années 1960, et qui fut le premier champion
du monde d'échecs sur ordinateurs. Il fait honneur à la déesse mythique du jeu
d'échecs : Caïssa.
1
ENSTA ParisTech
1
1
Présentation du projet
Depuis sa création en Inde au VIIIe siècle après. J.C., le jeux d'échecs,
surnommé le roi des jeux, a toujours fasciné l'homme pour ses aspects liés au
calcul, à la stratégie et à la tactique.
En 1789, Wolfgang von Kempelen présente, lors de nombreuses tournées, le
Turc, un automate capable de battre de bons joueurs d'échecs. Napoléon Premier
l'a ainsi appris à ses dépends. En réalité, c'était une supercherie ingénieuse. En
eet, un fort joueur de petite taille était caché à l'intérieur du core servant de
support à l'échiquier.
Dès l'apparition des premiers ordinateurs, les chercheurs ont entamé une
course visant à créer un joueur d'échecs électronique d'un niveau égal ou supérieur
à celui des meilleurs humains. En eet, beaucoup considéraient, qu'en cas de
réussite, ils détenaient la preuve de la faisabilité d'une machine intelligente. On
aurait réussit à inculquer à un ordinateur une méthode de réexion propre à
l'être humain.
Or, même si depuis 1997, année de la défaite du champion du monde Garry
Kasparov contre le supercalculateur Deep Blue (200 millions de positions évaluées par seconde), les programmes d'échecs sont devenus meilleurs que l'homme,
ils n'en sont pas plus intelligents. Leur force est essentiellement due à leur fantastique vitesse de calcul.
Ce projet va permettre de réaliser un programme en C d'échecs basique,
mais évolutif et ouvert. Les notions suivantes seront ainsi abordées :
Représentation de l'échiquier,
Déplacement des pièces,
Évaluation de positions,
Parcours optimisé d'un arbre des variantes,
Gestion du temps et arbitrage.
2
2
Cahier des charges
2.1
Modules obligatoires
Après une phase d'appropriation des règles du jeu d'échecs et de la convention de notation algébrique des coups, il est demandé de coder, en
langage C
et sous l'environnement Linux de l'ENSTA ParisTech, des modules ou unités
de compilation venant compléter la base logicielle décrite dans ce document et
permettant de réaliser les actions suivantes :
•
•
évaluation statique d'une position en fonction de critères à préciser ;
recherche du meilleur coup à jouer pour un camp et une profondeur donnés ;
•
diminution du temps de calcul par élagage de l'arbre des variantes.
L'ensemble des fonctions décrites supra fera l'objet de tests de vitesse d'exécution, selon un ou des protocoles qu'il conviendra de préciser.
2.2
Modules optionnels
Enn, il est proposé, pour les plus motivés et sous forme de bonus, d'implémenter tout ou partie des fonctionalités ci-dessous :
chargement et sauvegarde d'une partie au format
PGN2 ;
horloge double permettant de jouer en temps limité ;
bibliothèque d'ouvertures : suite de coups à jouer en début de partie de
manière quasi-instinctive, car déjà longuement étudiée ;
répertoire de nales : principe identique à la bibliothèque d'ouverture ;
table de transposition : zone mémoire de stockage de résultats d'évaluation
de positions. D'un accès rapide, elle permet d'éviter d'évaluer à nouveau
une position lors du parcours de l'arbre de recherche du meilleur coup ;
compatibilité du programme avec le protocole UCI
3 qui permet la com-
munication entre un moteur d'échecs et une interface utilisateur comme
Arena, Babachess, Xboard, eBoard. . .
pour les nostalgiques ou passionnés par le vintage , créer une interface
homme machine en mode texte i.e achage en mode caractère de l'échiquier
et des pièces, et saisie des coups au clavier. Le programme sera ainsi exécutable en mode console sans nécessité de posséder un environnement
graphique (GNOME, KDE,. . . ). Il sera même utilisable via une connexion distante bas débit.
2
Portable Game Notation. Ce format permet de noter une partie d'échecs. Le chier produit
est facilement exploitable par le joueur humain en l'ouvrant avec un éditeur de texte standard.
3
Universal Chess Interface
3
3
Supports fournis
3.1
Règles du jeu d'Echecs
Les règles ocielles du roi de jeux ainsi qu'une version synthétique gurent
sur la page [Wiki] du projet.
3.2
Base logicielle de Kaissa XXI
La base logicielle du projet Kaissa XXI se trouve aussi sur la page [Wiki]
du projet. C'est une archive au format
*.tar.gz
contenant le code au format
projet Code : :Blocks. Il contient l'interface graphique utilisant la bibliothèque
GTK+ [Gtk], le code de base avec les structures de données pour les pièces
et l'échiquier, la gestion et représentation de l'échiquier et le déplacement des
pièces.
Une séance de TD sera dédiée à commenter l'utilisation de cette base.
Limitations de la version
: Les actions suivantes ne sont pas codées dans la
version de base de Kaissa XXI : gestion des roques, prise en passant et promotion
du pion.
3.3
Code : :Blocks
CodeBlocks[CB] est un environnement de développement intégré opensource et multi-plateforme. Il vous facilitera la vie en eectuant les tâches
répétitives nécessaires au bon déroulement du projet. Par exemple, il ajoute
automatiquement les macros en début de chier an d'éviter plusieurs chargements d'un même chier d'entête, il gère sa propre liste de chiers et d'options
pour eectuer des compilations dans diérentes versions (par défaut Debug et
-I et -L),
VC++, etc).
Release, s'occupe des dépendances de bibliothèques externes (options
et peut même gérer l'utilisation de diérents compilateurs (G++,
remarque :
N'hésitez à regarder les transparents des séances magistrales
(cf poly IN104 Ÿ3 ).
Impossible de mettre un espace
Si ce problème vous arrive, vous utilisez sûrement la distribution
GNU/Linux Ubuntu.
Ce problème vient du plugin Code Completion qu'il vous faudra désactiver, à
moins que vous le préféreriez faire
Ctrl+Alt+Espace
à chaque fois que vous
souhaitez insérer un espace. Pour cela, sélectionnez le menu Plugins
→
Man-
age plugins. . . puis sélectionnez le plugin Code Completion et cliquez sur Disable
Installer CodeBlocks sur votre machine personnelle
Suivez le guide, tout est décrit sur Internet. . . [CBWin, CBTux]
4
4
Heuristiques et algorithmes étudiés
4.1
Heuristique d'évaluation de position
L'évaluation d'une position au jeu d'échecs est un problème complexe où la
part de subjectivité n'est pas négligeable dans la détermination des nombreux
critères qui vont permettre de noter in ne la position sur l'échiquier. Dans
ce domaine, on ne parle pas d'algorithme d'évaluation mais d'heuristique
d'évaluation. Etroitement liée à la performance dans la recherche du meilleur
coup, celle-ci est une composante principale de l'intelligence articielle d'un
programme d'Echecs.
Parmi les critères d'évaluation, on dénombre entre autres :
•
•
•
•
La valeur des forces en présence ;
La sécurité du Roi ;
La contrôle du centre par occupation ou attaque ;
Les degrés de liberté (nombre de mouvements classiques) ; on se référe à
la notion stratégique de jeu ouvert, fermé, semi-ouvert et semi-fermé ;
•
Et beaucoup d'autres critères stratégiques comme : la structure de pions, les colonnes ouvertes (demultiplient la puissance des Tours, surtout
doublées), paire de fous contre paire de cavaliers, les pions doublés,. . . .
Critère étudié :
Concernant le projet Kaissa XXI et compte tenu du temps
dédié limité, il est demandé de n'implémenter qu'une heuristique d'évaluation
fondé sur le permier critère énuméré ci-dessus. Les valeurs à utiliser sont : Pion
= 1, Cavalier = 3, Fou = 3, Tour = 5 et Dame = 9. Le Roi vaut une innité de
points. En eet, le Roi ne peut être capturé !
4.2
Algorithme MiniMax
S'appliquant à la théorie des jeux, l'algorithme MiniMax ou MinMax est un
algorithme utilisé au titre des jeux à deux joueurs à somme nulle. Pour une vaste
famille de jeux, le théorème du minimax de von Neumann assure l'existence d'un
tel algorithme, même si dans la pratique il n'est souvent guère aisé de le trouver.
Appliqué au jeu d'échecs, il amène l'ordinateur à parcourir l'ensemble de
l'arbre des variantes, pour un nombre limité de coups (profondeur de recherche)
et à leur assigner une valeur qui prend en compte les bénéces pour le joueur et
pour son adversaire. Le meilleur choix est alors celui qui minimise les pertes du
joueur tout en supposant que l'adversaire cherche au contraire à les maximiser
(le jeu est à somme nulle). L'adversaire est réputé jouer le meilleur coup à chaque
fois.
Principe :
L'algorithme MiniMax est simple : on visite l'arbre de jeu pour
faire remonter à la racine une valeur (appelée "valeur du jeu" qui est calculée
récursivement de la façon suivante :
• M inM ax(p) = f (p)
si
p
est une feuille de l'arbre où
d'évaluation de la position du jeu.
5
f
est une fonction
• M inM ax(p) = M AX(M inM ax(O1 ), ..., M inM ax(On )) si p est un noeud
Joueur avec ls O1 , ..., On .
• M inM ax(p) = M IN (M inM ax(O1 ), ..., M inM ax(On )) si p est un noeud
Opposant avec ls O1 , ..., On .
Fig. 1 Schéma MiniMax ; profondeur
p = 1;
feuille évaluée
Dans le schéma ci-dessus, les noeuds gris représentent les noeuds joueurs
et les bleus les noeuds opposants. Pour déterminer la valeur du noeud A, on
choisit la valeur maximum de l'ensemble des noeuds B (A est un noeud joueur).
Il faut donc déterminer les valeurs des noeuds B qui reçoivent chacun la valeur
minimum stockée dans leurs ls (noeuds B sont opposants). Les noeuds C sont
des feuilles, leur valeur peut donc être calculée par la fonction d'évaluation.
6
Fig. 2 Schéma MiniMax ; profondeur
p = 1;
tout noeud évalué
Le noeud A prend donc la valeur 5. Le joueur doit donc jouer le coup l'amenant en B2. En observant l'arbre, on comprend bien que l'algorithme considère que l'opposant va jouer de manière optimale : il prend le minimum. Sans ce
prédicat, on choisirait le noeud C1 qui propose le plus grand gain et le prochain
coup sélectionné amènerait en B1. Mais alors on prend le risque que l'opposant
joue C3 qui propose seulement un gain de 3.
En pratique, la valeur théorique de la position P ne pourra généralement
pas être calculée. En conséquence, la fonction d'évaluation sera appliquée sur
des positions non terminales. On considérera que plus la fonction d'évaluation
est appliquée loin de la racine, meilleur est le résultat du calcul. C'est-à-dire
qu'en examinant plus de coups successifs, nous supposons obtenir une meilleure
approximation de la valeur théorique donc un meilleur choix de mouvement.
Il existe diérents algorithmes basés sur MiniMax permettant d'optimiser la
recherche du meilleur coup en limitant le nombre de noeuds visités dans l'arbre
de jeu, le plus connu est l'élagage alpha-beta. En pratique, l'arbre est souvent
trop vaste pour pouvoir être intégralement exploré (comme par exemple pour le
jeu d'échecs ou de go). Seule une fraction de l'arbre est alors explorée.
En eet, aux Echecs, il existe en moyenne 35 coups possibles en milieu de
partie pour un camp à partir d'une position donnée. Pour une profondeur de
recherche
p,
correspondant à la somme du nombre de demi-coups des blancs
et des noirs, on aurait donc
p=4
35p
positions à évaluer. A titre d'exemple, pour
(2 coups blancs avec la réponse des noirs), cela ferait 1500625 évaluations
à eectuer !
7
4.3
Algorithme Alpha-Beta
L'élagage alpha-beta est une technique permettant de réduire le nombre de
n÷uds évalués par l'algorithme MiniMax.
L'algorithme MiniMax eectue en eet une exploration complète de l'arbre de recherche jusqu'à un niveau donné, alors qu'une exploration partielle de
l'arbre est généralement susante : lors de l'exploration, il n'est pas nécessaire
d'examiner les sous-arbres qui conduisent à des congurations dont la valeur ne
contribuera sûrement pas au calcul du gain à la racine de l'arbre. L'élagage
αβ
nous permet de réaliser ceci.
Plus simplement, l'élagage
αβ évite d'évaluer des noeuds de l'arbre de recherche
dont on est sûr que leur qualité sera inférieure à un noeud déjà évalué.
L'élagage
αβ
permet ainsi d'optimiser grandement l'algorithme MiniMax
sans en modier le résultat.
Principe :
α et β appartenant au domaine d'arrivée de
d'évaluation tel que α < β . On dénit la fonction AlphaBeta ainsi :
• AlphaBeta(P, α, β) = g(P ) si P est une feuille de l'arbre et g
On prend
la fonction
la fonction
d'évaluation du noeud.
• AlphaBeta(P, α, β) = min(β, max(−AlphaBeta(Oi , −β, −α))) où les Oi
sont les ls du noeud P .
On appelle fenêtre αβ le couple (α, β) où α et β sont les deux paramètres d'appel
de la fonction. Les noeuds élagués sont ceux qui seraient appelés avec une fenêtre
tel que
•
•
•
α ≥ β.
Il existe 3 types de noeuds ne pouvant donc pas être élagués :
Noeud de type 1 : fenêtre d'appel :
Noeud de type 2 : fenêtre d'appel :
Noeud de type 3 : fenêtre d'appel :
(−∞, +∞)
(−∞, β) avec β =6= +∞
(α, +∞) avec α =6= −∞
alpha est initialisé à -INFINI et beta à +INFINI
8
Le schéma ci-dessus présente les deux types de coupures possibles. Les noeuds
Min sont représentés par un rond bleu et les noeuds Max par un carré gris. Rappel : les noeuds Min prennent la valeur minimum de leurs ls (et respectivement
maximum pour les noeuds Max).
Coupure Alpha : le premier ls du noeud Min V vaut 4 donc V vaudra au
plus 4. Le noeud Max U prendra donc la valeur 5 (maximum entre 5 et
une valeur inférieure ou égale à 4).
Coupure Beta : le premier ls du noeud Max V vaut 4 donc V vaudra au
minimum 4. Le noeud Min U prendra donc la valeur 3 (minimum entre 3
et une valeur supérieure ou égale à 4).
Nous allons illustrer l'algorithme sur l'arbre ci-dessous déjà étiqueté avec les
valeurs d'un minimax. Le résultat obtenu est le schéma ci-dessous.
9
Fig. 3 Exemple d'élagage Alpha-Beta
Plusieurs coupures ont pu être réalisées :
1. Le noeud MIN vient de mettre à jour sa valeur courante à 4. Celle-ci, qui
ne peut que baisser, est déjà inférieure à
α = 5, la valeur actuelle du noeud
MAX précédent. Celui-ci cherchant la valeur la plus grande possible, ne
la choisira donc de toute façon pas.
2. Le noeud MIN vient de mettre à jour sa valeur courante à 6. Celle-ci, qui
ne peut que baisser, est déjà égale à
α = 6,
la valeur actuelle du noeud
MAX précédent. Celui-ci cherchant une valeur supérieure, il ne mettra de
toute façon pas à jour sa valeur que ce noeud vaille 6 ou moins.
3. Le noeud MIN vient de mettre à jour sa valeur courante à 5. Celle-ci, qui
ne peut que baisser, est déjà inférieure à
α = 6, la valeur actuelle du noeud
MAX précédent. Celui-ci cherchant la valeur la plus grande possible, ne
la choisira donc de toute façon pas.
10
Références
http://www.ensta.fr/~bmonsuez/Cours/doku.php?id=in104
[CB] http://www.codeblocks.org/
[CBWin] http://baptiste-wicht.developpez.com/tutoriel/outils/
code-blocks/install/
[CBTux] http://fearyourself.developpez.com/tutoriel/linux/ubuntu/
installation-code-blocks/
[MVC] http://fr.wikipedia.org/wiki/Mod%C3%A8le-Vue-Contr%C3%B4leur
[Gtk] http://www.gtk.org/documentation.html
[GtkDVP] http://gtk.developpez.com/
[Wiki]
11