Le sujet

Formations en Informatique de Lille – 2008/2009
Apprentissage par l’Exemple
mars 2009
Apprendre le Memory
1
Introduction
Memory, parfois appelé le pou chinois ou Concentration est un jeu de cartes populaire très répandu. La
mémoire semble y joue un rôle important, mais si on y regarde bien, on se rend compte que c’est en fait un
jeu de stratégie.
S’il existe une stratégie gagnante, on peut espérer trouver un programme qui la trouve par apprentissage,
comme c’est le cas avec Jenga. Si ça marche (c’est à dire si on arrive à définir un joueur qui apprend à gagner
à Memory), on essaiera de comprendre la stratégie mise en oeuvre, afin de l’exprimer plus simplement.
Enfin, on étudiera ces conclusions pour vérifier que la stratégie trouvée par le programme est :
– intéressante ou pas.
– conforme à celle trouvée par les chercheurs.
2
Le jeu
Memory se joue avec un jeu de cartes où toutes les cartes sont présentes en deux exemplaires. Il existe dans
le commerce des jeu ’tout faits’ avec des dessins créés pour l’occasion, mais on peut ausi jouer avec deux
jeux de cartes identiques. C’est cette deuxième possibilité que nous utiliserons dans toute la suite.
2.1
–
–
–
–
Les règles
Deux jeux de 52 cartes sont mélangés et placés faces cachées sur la table.
Chaque joueur à son tour retourne successivement deux cartes.
Si les deux cartes sont identiques, il les ramasse, marque un point, et peut rejouer.
Sinon, son tour est terminé, il replace les deux cartes faces cachées et c’est au joueur suivant de jouer.
2.2
Remarques
Si les deux joueurs ont une mémoire absolue, il n’est pas nécessaire de replacer les cartes face cachées, on
peut se contenter de les laisser visibles sur la table.
2.3
Stratégie
Dans ce cas, lorsque c’est à lui de jouer, le joueur peut choisir parmi au plus quatre coups possibles :
1. Retourner une carte inconnue, puis une deuxième carte inconnue.
2. Retourner une carte inconnue, puis une carte connue.
3. Retourner une carte connue, puis une carte inconnue.
4. Retourner une carte connue, puis une carte connue.
Dans les deux premiers cas, si la première carte retournée correspond à une carte déjà connue, le joueur
prend la paire ainsi constituée, marque un point et rejoue : faire autrement n’est sûrement pas une bonne
stratégie.
Pour l’étude détaillée de la stratégie optimale, vous êtes fortement incités à lire l’article court, illustré, en
français, et facile à comprendre fourni sur la page du cours. On supposera dans toute la suite de ce sujet que
vous avez lu cet article. . .
Les plus courageux et les polyglottes matheux consulteront avec profit l’article de Zwick (le même que pour
l’article sur Jenga) et Patterson lui aussi disponible sur la page du cours.
3
L’apprentissage
Comme pour les jeux précédents, le principe sera le suivant :
– Dans un premier temps, on accumulera des exemples en jouant un certain nombre de parties aléatoirement.
– Lorsqu’on jugera que le nombre d’exemples est suffisant, on construira un classifieur.
– Lors des parties suivantes, on utilisera ce classifieur pour choisir les coups à jouer.
– Tout au long du processus d’apprentissage, on collectera des informations sur le score final des parties,
afin de pouvoir juger de la réalité et de la qualité de l’apprentissage.
Cette fois-ci, nous utiliserons un réseau de neurones. D’un point de vue pratique, celà nous permettra
surtout de pouvoir remplacer la classe, forcément discrète lorsqu’on utilise un arbre de décision, par une
valeur continue.
3.1
Codage des exemples
On utilisera le codage suivant :
– La proportion de cartes connues.
– la proportion de cartes inconnues.
– Le score du joueur, ramené entre 0 et 1 (i.e. la proportion de paires gagnées). Cet attribut sera aussi la
classe.
Si vous avez bien lu l’article la stratégie du pou chinois, vous avez remarqué de petites différences entre notre
définition d’une configuration de jeu et celle décrite dans cet article. . .
Vous pouvez définir d’autres codages, mais vous aurez alors à créer les classes permettant de les manipuler. . .
Si vous choisissez cette option, il vous faudra l’expliciter dans votre compte-rendu.
4
Travail demandé
Vous devez construire un joueur censé apprendre, le faire jouer contre un ou plusieurs types de joueurs, et
produire des statistiques sous forme de courbes prouvant que l’apprentissage est réel.
Les conclusions peuvent être différentes selon le type d’adversaire, à vous d’expliquer ces différences.
Si l’apprentissage est effectif, vous devrez essayer de comprendre la stratégie mise en œuvre par le joueur
apprenant, et de l’expliquer de façon claire, un peu comme dans la figure de la page 122 de l’article de Pour
la Science.
Vous rendrez donc un fichier compressé contenant :
1. Un compte-rendu décrivant votre expérience :
– protocole, résultats.
– Interprétation de la stratégie utilisée après apprentissage.
2. Le source de votre joueur apprenant étendant la classe Joueur. (Si vous changez le codage des exemples,
fournissez en plus toutes les classes nécessaires à une bonne exécution du programme !)
2
5
Les classes fournies
Les fichiers source de ces classes sont disponibles sur la portail, à la page du cours.
5.1
Paquetage gamespec
Ce paquetage contient la définition du jeu :
– Color : un type énuméré pour les quatre couleurs de cartes.
– FacialValue : un type énuméré pour les valeurs des cartes.
– Card : la définition d’une carte (et de l’égalité de deux cartes).
– CardGame : un jeu de 52 cartes.
– Board : le plateau de jeu :
– Deux paquets de 52 cartes mélangés.
– La liste des cartes connues.
– La liste des cartes non encore retournées.
– Des fonctions pour manipuler les cartes (voir commentaires dans le source).
– Coup : un type énuméré pour les quatre coups possibles.
– Config : un quadruplet mémorisant une configuration en cours de partie et le score de la partie :
– La proportion de cartes connues.
– la proportion de cartes inconnues.
– Le coup joué.
– Le score de la partie où on a rencontré cette configuration.
5.2
Paquetage player
Contient la définition des joueurs et de leurs stratégies.
Un Joueur demande à sa stratégie de choisir le coup à jouer, en fonction de l’état du plateau de jeu (méthode
choix de l’objet Strategie)
La méthode myTurn de la classe Joueur déroule ce coup : il y a pas mal de cas à distinguer, mais d’une
part, les commentaires devraient vous aider à vous y retrouver, d’autre part, si vous faites confiance à cette
méthode, il n’y a à priori pas de raison de la changer.
Les joueurs ne différent dont les uns des autres que par leur stratégie :
– Joueur : sa stratégie Aleatoire joue un des coups possibles, selon la configuration, de manière équiprobable.
– JoueurAleatoire2 : on commence toujours par tirer une carte inconnue
– JoueurAleatoireTrois : si c’est possible, on retourne deux cartes inconnues, sinon, on commence par
une carte inconnue.
Le JoueurAMemoire, et sa StrategieAMemoire associée, définit et construit un dataset (classe weka.core.Instances)
à partir des coups joués et des scores de parties.
Le JoueurAMemoire doit mettre à jour un certain nombre d’informations à la fin d’une partie, c’est le rôle
de la méthode endOfGame(), qui elle-même invoque la méthode correspondante de la stratégie associée.
A vous de définir une stratégie apprenante, héritant de StrategieAMemoire, qui utilisera les instances
construites lors de parties aléatoires pour apprendre.
5.3
Paquetage tests
Ce paquetage ne contient qu’un exemple de programme principal, faisant s’affronter deux joueurs, et récupérant
les résultats des parties pour affichage dans gnuplot.
6
Conseils
– La stratégie adoptée dépendra sans doute de l’adversaire : essayez-en plusieurs, et constatez les différences
d’apprentissage.
3
– Que se passe-t-il lorsque deux joueurs apprenants se rencontrent ?
7
les réseaux de neurones
Le principe des réseaux de neurones sera vu en cours. Pour ce TP, on peut se contenter de les voir comme
une autre sorte de classifieur, possédant les mêmes fonctionnalités que les arbres de décision, avec l’avantage
de pouvoir manipuler des classes continues, au lieu de se limiter aux classes discrètes.
On peut donc utiliser les méthodes :
– buildClassifier(Instances dataset)
– distributionForinstance(Instance example)
– classifyInstance(instance example)
Des options spécifiques aux réseaux de neurones peuvent être trouvées dans la javadoc weka, certaines seront
expliquées lors des séances de TP.
4