M1–Master d’informatique – 2008/2009

Apprentissage à Partir d’Exemples

janvier 2009

Apprendre la stratégie de l’adversaire

1 But
Soit un jeu à deux joueurs quelconque. Supposons que l’un des deux joueurs suive une stratégie simple
(répétitive par exemple). Peut-on définir un joueur ’apprenant’ qui, en regardant les coups joués précédemment
par son adversaire, serait capable de prédire à coup sûr, ou avec une bonne probabilité de succès, le prochain
coup de son adversaire ?
Si la réponse est oui, on peut alors se poser d’autres questions :
par exemple, concernant les stratégies à deviner :
– Existe-t-il des stratégies ’non devinables’ ?
– Certaines stratégies sont-elles plus dures à apprendre que d’autres ?
– Existe-t-il des stratégies difficiles à deviner ?
Concernant le mode opératoire du joueur qui doit deviner :
– Quel algorithme (ou famille d’algorithmes) choisir ?
– Quand faut-il apprendre, et quand faut-il utiliser ce que l’on a appris ?

2 Un premier jeu
Le jeu que nous allons considérer est très simple, sa programmation ne pose aucun problème, ce qui permettra
de se focaliser sur la programmation du joueur apprenant.
Chifoumi, ou Ciseaux, Pierre, Feuille est un jeu à deux joueurs. Une partie se déroule en n manches, où
une manche consiste pour chaque joueur à annoncer (simultanément) l’un des trois mots Ciseaux, Pierre ou
Feuille.
– Si les deux joueurs annoncent la même chose, la manche est nulle, personne ne marque de points.
– Les Ciseaux l’emportent sur la Feuille (ils la coupent).
– La Pierre l’emporte sur les Ciseaux (elle les brise).
– La Feuille l’emporte sur la Pierre (elle l’enveloppe).

3 Les implémentations de base

Les indications, exemples, et implémentations décrites dans cette section sont fournies pour vous aider. Si
vous préférez les définir différemment ou les modifier, libre à vous : le principal étant que vous puissiez
évaluer la performance de votre joueur apprenant face à ses adversaires.

3.1 Récupérer les sources

Les paquetages chifoumi, clavier et partie sont fournis ’en entier’.
Le paquetage joueurs contient la description de plusieurs types de joueurs (mais pas les joueurs utilisant
les arbres de décision . . .).
 Le programme premierEssai.java contient un exemple d’utilisation des classes.
Ces paquetages sont disponibles sur la page du cours d’APE sur le serveur du FIL (fichier sources.tgz)

3.2 Compiler un programme

Lorsque vous utiliserez des classes de Weka, vous devrez indiquer au compilateur où trouver ces classes :
javac -d classes -classpath /opt/weka-3-4-11/weka.jar -sourcepath sources sources/premierEssai.java
Pour l’exécution, c’est plus simple :
java -cp classes premierEssai

3.3 Les coups possibles

Le paquetage chifoumi ne contient que la classe Chifoumi.java, qui définit les trois coups possibles et les
méthodes permettant de les comparer entre eux, de les transformer (entiers ou chaı̂ne). . .

3.4 L’arbitre
La classe Partie sert à faire s’affronter deux joueurs, leur demande de jouer, informe chacun du coup joué
par l’autre, et affiche les scores. Le programme principal suivant se contente donc de créer une partie, de
définir les joueurs, et de lancer la compétitions :

import partie.Partie;
import joueurs.*;

public class competition{

public static void main(String argv[]){

Joueur j1=new JoueurReplique();
Joueur j2=new Joueurj48(100);
Partie p=new Partie(j1,j2);
p.setVerbosity();
p.Play(10000);
}
}

3.5 Les joueurs

3.5.1 L’interface
On peut définir l’interface Joueur minimale comme étant composée de deux méthodes :
– L’une permettant d’annoncer le coup choisi.
– L’autre permettant d’informer le joueur du coup joué par son adversaire.

package joueurs;

import chifoumi.*;

public interface Joueur{

public Chifoumi coupJoue();

public void memorise(Chifoumi coupAdverse);
}

2
3.5.2 Les adversaires
On peut définir facilement plusieurs types de joueurs. Tout d’abord les joueurs qui ne s’occupent pas de leur
adversaire :
– Le joueur aléatoire : il est impossible d’apprendre sa stratégie.
– Le joueur préférentiel : il joue un coup plus souvent que d’autre.
– Le joueur périodique : la succession des coups qu’il joue est périodique : la période peut être plus ou moins
longue.
– Le joueur markovien : la probabilité qu’il joue un coup dépend du coup qu’il a joué au coup précédent.
– ...
Les joueurs dont la stratégie dépend des coups joués par leur adversaire :
– Le joueur réplicant : il joue le coup joué au coup précédent par son adversaire.
– Le joueur réplicant-méchant : il joue le coup qui aurait battu le coup précédent de son adversaire.
– Le joueur statisticien : il joue le coup qui gagne contre le coup le plus souvent joué par son adversaire.
– ...
Certaines de ces stratégies vous sont fournies dans le paquetage joueur, les autres peuvent s’en déduire
facilement.
D’autres stratégies sont possibles, vous pouvez les définir, les programmer et les diffuser . . .

3.5.3 Le joueur apprenant

Un premier joueur apprenant pourrait être défini de la manière suivante :
– Dans un premier temps, il joue au hasard (ou suivant une stratégie rigide), et observe le comportement
de son adversaire.
– Une fois qu’il a accumulé suffisamment d’informations sur son adversaire, il essaie de comprendre sa
stratégie.
– Une façon de comprendre le comportement de l’adversaire, c’est de construire un classifieur qui, étant
donnés les n derniers coups de l’adversaire, lui retourne le coup suivant.
– Pour cela, il découpe la séquence des k derniers coups de son adversaire en k − n fenêtres de taille n + 1 :
les n premières valeurs sont les coups connus, la dernière valeur est celle qu’il faut deviner.
– Il range ses exemples dans un ensemble d’apprentissage (classe Instances).
– Il construit un arbre de décision (par exemple).
– une fois qu’il a son classifieur, il lui fournit en entrée les n derniers coups de son adversaire, et attend la
réponse.
– Il joue alors le coup qui peut vaincre cette prédiction.
En résumé, le premier joueur apprenant que vous allez définir :
– Contiendra un arbre de décision
– Maintiendra l’historique complet des coups joués par son adversaire
– Dès que possible, il construira le classifieur.
– Il utilisera ce classifieur pour prévoir le coup de l’adversaire.
– L’arbre une fois construit est-il intangible ?
– Quand et comment le modifier ou le reconstruire ?
Question 3.1 : Construisez un joueur apprenant basé sur un arbre de décision, contrôlez son efficacité contre
divers adversaires. Affichez et interprétez l’arbre qu’il construit.

4 Evaluation du résultat
On peut suivre l’efficacité de l’apprentissage contre un joueur donné en regardant l’évolution du nombre (ou
de la proportion) de parties gagnées, nulles, perdues : la classe Partie affiche ces résultats, qu’on peut lire
dans n’importe quel logiciel de tracé de courbes (gnuplot, par exemple).

3
Les courbes suivantes vous donnent quelques exemples de comportement.

Joueur aleatoire contre apprenant

400
Aleatoire gagne
Match nul
Apprenant gagne
350

300

Nombre de parties 250

200

150

100

50

0
0 100 200 300 400 500 600 700 800 900 1000
Nombre de parties jouees

Fig. 1 – Aleatoire vs Apprenant : on ne peut rien apprendre

5 Un pas plus loin

Et quand le joueur adverse décide de son coup, non seulement en fonction de ses coups précédents, mais
aussi en fonction des coups du joueur apprenant ? Est-il possible encore à celui-ci de jouer gagnant sur le
long terme ?
Une première réponse consiste à dire que puisque c’est comme ça, il va mémoriser non seulement les coups
de son adversaire, mais aussi les siens.
Question 5.1 : Construisez ce joueur. Est-il plus efficace, moins efficace ? Existe-t-il des stratégies adverses
qu’il comprend mieux que son grand frère ?

4
 Joueur repliquant mechant contre apprenant
900
Periodique gagne
Match nul
800 Apprenant gagne

700

600

Nombre de parties
500

400

300

200

100

0
0 100 200 300 400 500 600 700 800 900 1000
Nombre de parties jouees

Fig. 2 – Periodique vs Apprenant : Quand l’apprenant comprend, il ne perd plus jamais

Joueur markovien contre apprenant

3000
Markovien gagne
Match nul
Apprenant gagne

2500

2000
Nombre de parties

1500

1000

500

0
0 500 1000 1500 2000 2500 3000 3500 4000 4500 5000
Nombre de parties jouees

Fig. 3 – Markovien vs Apprenant : l’apprenant ne gagne pas toujours. . .

5
 Joueur repliquant mechant contre apprenant
8000
Repliquant gagne
Match nul
Apprenant gagne
7000

6000

5000
Nombre de parties

4000

3000

2000

1000

0
0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000
Nombre de parties jouees

Fig. 4 – Répliquant méchant vs Apprenant : l’apprenant comprend le truc après 500 parties, mais perd
encore parfois. . .mais après avoir joué 7000 parties, il ne perd plus.