Vous êtes sur la page 1sur 15

M1–Master d’informatique – 2008/2009

Apprentissage `a partir d’exemples

janvier 2009

Weka

Pr´esentation

Weka (Waikato Environment for Knowledge Analysis) est un ensemble d’outils permettant de manipuler et d’analyser des fichiers de donn´ees, impl´ementant la plupa rt des algorithmes d’intelligence artificielle, entre autres, les arbres de d´ecision et les r´eseaux de neurones. Il est ´ecrit en java, disponible sur le web 1 , et s’appuie sur le livre :

Data Mining, practical machine learning tools and techniqu es with Java implementations Witten & Frank Editeur : Morgan Kauffman

Il se compose principalement :

– De classes Java permettant de charger et de manipuler les do nn´ees.

– De classes pour les principaux algorithmes de classification supervis´ee ou non supervis´ee.

– D’outils de s´election d’attributs, de statistiques sur ces attributs.

– De classes permettant de visualiser les r´esultats.

On peut l’utiliser `a trois niveaux :

– Via l’interface graphique, pour charger un fichier de donn´ees, lui appliquer un algorithme, v´erifier son efficacit´e.

– Invoquer un algorithme sur la ligne de commande.

– Utiliser les classes d´efinies dans ses propres programmes pour cr´eer d’autres m´ethodes, impl´ementer d’autres algorithmes, comparer ou combiner plusieurs m´ethodes. C’est cette troisi`eme possibilit´e qui sera utilis´ee en travaux pratiques.

1 But des travaux pratiques

L’interˆet de Weka dans le cadre du cours d’Apprentissage pa r l’exemple est multiple :

– Pouvoir mettre en œuvre les algorithmes ´etudi´es en cours en grandeur nature, sans devoir r´eecrire tout le code correspondant (quoiqu’une telle r´e´ecriture peut s’av´erer tr`es fructueuse !).

– Comprendre et utiliser intelligemment les diff´erentes so rties de ces algorithmes.

– Pouvoir programmer des agents intelligents en un temps raisonnable, pour des tˆaches (pour nous, princi- palement des jeux) non triviaux.

– Evaluer les performances d’un algorithme.

– Comparer les performances de deux algorithmes.

– Etudier le rˆole des param`etres d’un algorithme.

– Combiner plusieurs algorithmes.

– Eventuellement (mais l`a, c’est un peu plus dur), d´efinir un nouvel algorithme.

1 www.cs.waikato.ac.nz/ml/weka

2

Liens et ressources

Le site de Weka contient :

– La version courante (´evolution rapide).

– Un lien vers la javadoc.

– Quelques tutoriaux.

– La liste de diffusion r´epond aux questions de tout type concernant Weka (y compris les questions de

d´ebutants

.). C’est en anglais.

Il existe un ”wekawiki” qui regroupe des tutoriaux, une FAQ et d’autres infos pour l’installation et l’utili- sation de weka (en anglais) `a l’adresse suivante : http://weka.wiki.sourceforge.net/

La javadoc est dans /opt/weka/weka-3-4-13/doc

3 Installation, initialisation

Weka est install´e dans les salles TP (/opt/weka/weka-3-4-13/weka.jar). Si vous voulez l’employer chez vous :

– Charger l’archive zip `a partir du site de Weka

– D´ecompressez-la.

– C’est tout

– Les classes sont dans weka.jar

– Les sources dans weka-src.jar

Tutorial.pdf est une pr´esentation assez pouss´ee des fonctionnalit´es de Weka

Vous trouverez en annexe de cette fiche de TP une br`eve description de l’utilisation de l’interface graphique de Weka .

3.1 Weka dans Eclipse

Sous Eclipse, si vous cr´eez un projet qui aura besoin de Weka , vous pouvez indiquer que vous voulez utiliser weka.jar :

– Project −→ properties −→ onglet Librairies

– Add external jar (ici /opt/weka/weka-3-4-13/weka.jar)

Programmer avec Weka

En travaux pratiques, nous utiliserons les algorithmes de classification impl´ement´es par Weka pour exp´erimenter des m´ethodes, r´esoudre des probl`emes, en nous concentra nt sur l’utilisation et les r´esultats fournis par ces impl´ementations, sans avoir a` r´eecrire `a chaque fois le s algorithmes. Utiliser Weka nous permettra par exemple de d´efinir un protocole ou un prog ramme g´en´erique d’apprentissage o`u il nous suffira de changer une ligne dans le programme pour p ouvoir utiliser un classifieur `a la place d’un autre. Pour pouvoir utiliser les algorithmes dans nos programmes, il nous faut :

– Pouvoir d´efinir ou charger `a partir d’un fichier un ensemble d’exemples d’apprentissage.

– Connaˆıtre les quelques m´ethodes qui permettent de d´efinir, initialiser et utiliser un classifieur.

– Connaˆıtre la m´ethode qui permet d’utiliser un classifieur pour trouver la classe d’un nouvel exemple.

– Afficher, lire, interpr´eter les classifications obtenues.

2

4

Compilation, ex´ecution

Pour pouvoir compiler et ex´ecuter les programmes utilisant Weka , il faut demander `a javac et java d’aller chercher les classes de Weka . Celles-ci sont `a l’int´erieur du fichier weka.jar .

Compiler : javac -classpath /opt/weka/weka-3-4-13/weka.jar Exempl e.java

Executer : java -cp . :/opt/weka/weka-3-4-13/weka.jar Exemple

Mais sous Eclipse, `a condition d’avoir configur´e le projet comme indiqu´e ci-dessus, il n’y a plus rien `a

5 Br`eves notions d’apprentissage

Le cadre dans lequel nous allons travailler, et les algorithmes que nous ´etudierons et utiliserons se basent sur le sch´ema de fonctionnement suivant :

On dispose d’un ensemble d’exemples, chaque exemple ´etant d´efini par :

 

– Sa description : c’est un ensemble de valeurs d´efinissant c et exemple (par exemple ses dimensions, sa

couleur

.)

– La classe qu’on lui a associ´ee (avec l’aide d’un expert humain, par

.)

On fournit cet ensemble d’exemples `a un programme qui va g´en´erer un classifieur. Un classifieur est un programme qui, quand on lui fournira un exemple, essaiera de deviner sa classe. Dit autrement, le programme essaie de deviner la classe d’un exemple `a partir de sa description. Dit encore autrement, le programme cherche la relation qui lie la description `a la classe.

Si tout s’est bien pass´e, on dispose maintenant d’un classifieur qui va agir un peu comme un oracle, pour deviner la classe d’un exemple.

6

D´efinir un ensemble d’apprentissage

 

Un ensemble d’apprentissage est d´efini dans Weka par la classes Instances (au pluriel !). Un objet de cette classe contient :

– une description de la structure des exemples (liste des attributs, type de chaque attribut, indice de l’attribut qui sert de classe).

– La liste des exemples.

6.1 Charger un ensemble d’exemples

On peut charger un ensemble d’exemples `a partir d’un fichier de suffixe .arff . On utilise alors le construc- teur : Instances(java.io.Reader reader) Exemple :

reader = new FileReader(filename); instances = new Instances(reader);

Le r´epertoire /opt/weka/weka-3-4-13/data contient quelques fichiers

6.2 Construire un ensemble d’exemples

Il faudra, dans l’ordre :

– D´efinir quels sont les attributs, et leur type.

– Construire un ensemble d’exemples `a partir de ces attributs.

– D´efinir l’attribut qui jouera le rˆole de la classe.

– Construire chaque exemple, et l’int´egrer `a l’ensemble.

3

6.2.1

D´efinir les attributs

Les deux principaux types d’attributs dans Weka sont :

Attributs Num´eriques Le constructeur est Attribute(String attributeName) : il n’y a rien d’autre `a d´efinir pour le sp´ecifier compl`etement.

Attributs Nominaux La construction se fait en deux temps :

– Stocker les valeurs que peut prendre cet attribut :

– Cr´eer un FastVector de la bonne taille.

– Utiliser la m´ethode addElement de FastVector pour ajouter chacune des valeurs.

– Cr´eer l’attribut avec le constructeur Attribute(String attributeName,FastVector attributeVa lues)

Exemples (tir´es de la javadoc d’Attribute )

// Cr´eer les attributs num´eriques "length" and "weight" Attribute length = new Attribute("length"); Attribute weight = new Attribute("weight");

// Cr´eer un FastVector pour contenir les valeurs "first", " second", "third" FastVector my_nominal_values = new FastVector(3); my_nominal_values.addElement("first"); my_nominal_values.addElement("second"); my_nominal_values.addElement("third");

// Cr´eer un attribut discret position pouvant prendre les t rois valeurs // "first", "second", "third" Attribute position = new Attribute("position", my_nomina l_values);

6.2.2 Construire un ensemble d’exemples `a partir de ces attributs

Le constructeur Instances(String name,FastVector attInfo,int capacity) permet de d´efinir un en- semble d’exemples :

name Le nom de la relation (tel qu’il apparaˆıt en premi`ere ligne du fichier arff)

attInfo Le FastVector contenant la d´efinition des attributs.

capacity La taille initiale de l’ensemble (peu important : s’il n’y a plus de place pour un nouvel exemple, on en cr´ee automatiquement).

Exemple :

// Cr´eer trois attributs A1,A2,A3 Attribute A1=new Attribute(‘‘nom_A1’’) // Un attribut num erique Attribute A2=new Attribute(‘‘nom_A2’’,my_nominal_valu es) // un attribut discret dont les valeurs // possibles sont rang´ees dans le vecteur //value_Vector (voir ci-dessus) Attribut A3=new Attribute(‘‘nom_A3’’,my_nominal_value s) // Rien n’emp^eche deux attributs de prendre // leurs valeurs dans le m^eme ensemble

// Regrouper les trois attributs dans un m^eme vecteur FastVector attName=new FastVector(3);

attName.addElement(A1);

attName.addElement(A2);

attName.addElement(A3)

4

// Cr´eer l’ensemble d’Instances Instances dataset=new Instances(‘‘nom_du_fichier’’,at tname,1000);

Attention : la classe FastVector est utilis´ee deux fois avec des rˆoles diff´erents :

– la premi`ere fois pour regrouper les valeurs possibles d’un attribut discret (FastVector de String).

– la deuxi`eme fois pour regrouper les attributs d´ecrivant chaque exemple (FastVector d’Attribute).

6.2.3 D´efinir la classe

C’est la m´ethode :

public final void setClass(Attribute att) o`u att est l’objet de type attribut qui servira de classe. On peut aussi fixer la classe en donnant son rang parmi les attributs. Usuellement, la classe est le dernier a ttribut de la liste, mais ca¸ n’a rien d’obligatoire :

// Indique que la classe est le dernier attribut de la descrip tion instances.setClassIndex(instances.numAttributes() - 1 );

6.2.4 Construire chaque exemple, et l’int´egrer `a l’ensemble

Un exemple est un objet de la classe Instance (au singulier !). On peut utiliser le constructeur :

Instance(int numAttributes) , qui construit un exemple vide avec numAttributes attributs. Il faut fixer la valeur de chaque attribut, avec une des m´etho des setValue de la classe Instance . Exemple :

// Cr´eer un exemple vide ayant trois atttributs Instance inst = new Instance(3);

// fixe les valeurs des attributs"length", "weight", et "po sition" pour cet exemple inst.setValue(length, 5.3); inst.setValue(weight, 300); inst.setValue(position, "first");

Enfin, ne pas oublier de pr´eciser `a quel ensemble appartient cet exemple, et ajouter ’physiquement’ cet exemple `a l’ensemble :

// Int`egre cet exemple `a l’ensemble dataset inst.setDataset(dataset); dataset.add(inst);

6.3 Application : Les Moines ( ?)

Le probl`eme des moines (Monk) est un probl`eme artificiel qui sert `a tester les algorithmes de classification. Chaque exemple est la description d’un robot :

– Forme de la tˆete : ronde, carr´ee ou octogonale.

– Forme du corps : rond, carr´e ou octogonal.

– Sourire : oui ou non.

– Tenant : ´ep´ee, ballon ou drapeau.

– Couleur du costume : rouge, jaune, vert, bleu.

– Porte une cravate : oui ou non.

5

Soit en tout 432 descriptions diff´erentes. Il existe plusieurs probl`emes :

Probl`eme 1 Le corps a la mˆeme forme que la tˆete ou bien le costume est rou ge.

Probl`eme 2 Deux des attributs exactement ont comme valeur la premi`ere valeur de l’attribut.

Probl`eme 3 De deux choses l’une :

– Le costume est vert et il tient une ´ep´ee ou bien

– Le costume n’est pas bleu et le corps n’est pas un octogone.

Question 6.1 : Construisez l’ensemble des exemples pour le probl`eme 1, et sauvez le r´esultat dans un fichier arff.

7 Construire un classifieur

Les arbres de d´ecision correspondent `a la classe weka.classifiers.trees.J48, et sont une sous-classe de weka.classifiers.Classifier . Dans ce premier TP, on d´esire juste instancier un classifie ur, l’entraˆıner sur un jeu de donn´ees, et l’utiliser pour classer de nouveaux exemples. On a donc besoin des m´ethodes :

buildClassifier(Instances data)

classifyInstance(Instance instance)

Question 7.1 :

Ecrire un programme qui :

– Lit un fichier arff

– Instancie un arbre de d´ecision (consid´er´e comme ´etant un Classifier ).

– Construit l’arbre `a partir des exemples.

– Affiche le r´esultat sur la sortie standard.

Question 7.2 :

Sur le sch´ema du programme pr´ec´edent, utilisez plusieur s Classifier de sous-classes diff´erentes `a partir du mˆeme fichier de donn´ees.

8 Utiliser le classifieur

Une fois que le classifieur est construit, on peut l’utiliser pour classer de nouveaux exemples. La m´ethode :

public double classifyInstance(Instance instance) de la classe Classifier retourne un r´eel qui correspond `a la classe attribu´ee par le classifieur `a l’exemple pass´e en param`etre. Dans le cas o`u la classe est discr`ete, comme par exemple qua nd le classifieur est un arbre de d´ecision, il faut encore reconvertir ce r´eel pour retrouver la valeur nomina le de l’attribut classe. Les concepteurs de Weka ont pr´ef´er´e coder en interne la valeur de chaque attribut par un r´eel, mais dans le cas des attributs nominaux, ce r´eel est en fait un entier, qui est l’indice de la valeur de l’attribut. Par exemple, si la classe ne peut prendre que les trois valeur s first, second,third , et que l’on construit un classifieur, la r´eponse de ce classifieur pour un exemple q uelconque sera une des trois valeurs r´eelles 0.0, 1.0, 2.0. La m´ethode String value(int j) de la classe Attribute retransformera ce r´eel en first, second ou third

6

9

Un exemple r´ecapitulatif

Le programme de la figure 4, aussi disponible sur la page web du cours, reprend `a peu pr`es toutes les notions abord´ees dans ce TP :

– On d´efinit un ensemble d’exemples.

– On cr´ee tous les exemples.

– On choisit le classifieur, on le construit.

– On calcule ’`a la main’ son taux d’erreur sur l’ensemble d’a pprentissage.

La classe peut prendre deux valeurs, vrai et faux , le premier attribut vaut pluie ou soleil , le second est un r´eel compris entre 0 et 1. la classe vaut vrai si :

– ou bien il fait soleil.

– ou bien il pleut, mais le deuxi`eme attribut est inf´erieur `a 0.5.

Question 9.1 : Reprendre le programme de la premi`ere question de la sectio n 7, en affichant, pour chaque exemple :

– Sa description

– Sa classe (qui fait partie de sa description

– La classe que lui attribue le classifieur.

.)

10 Interface graphique

Elle se lance par java -jar /opt/weka/weka-3-4-13/weka.jar On a alors le choix principalement entre :

Simple CLI Un interpr´eteur de ligne de commande.

Explorer une interface graphique.

Choisissez l’Explorer, on obtient un ´ecran ressemblant `a la figure 5. Les six onglets correspondent soit `a des ´etapes du process us d’apprentissage, soit `a des classes d’algorithmes de classification (supervis´ee ou non) :

Preprocess : La saisie des donn´ees, l’examen et la s´election des attri buts, les transformations d’attributs.

Classify : Les m´ethodes de classification.

Cluster : Les m´ethodes de segmentation (clustering).

Associate : Les r`egles d’association.

Select attributes : L’´etude et la recherche de corr´elations entre attributs .

Visualize : repr´esentations graphiques des donn´ees.

10.1 Preprocess

Un exemple de d´ebut de fichier est donn´e sur la figure 6.

Ce sous-menu permet de charger un fichier de donn´ees. On peut charger un fichier au format sp´ecifique de Weka, le format arff , qui se compose :

– du nom de la relation : @relation ’labor-neg-data’

– de la liste des noms d’attributs (@attribute ’duration’ real

.) et du type de valeurs :

7

– nominale : @attribute ’cost-of-living-adjustment’ {’none’,’tcf’, ’tc’}

– r´eelle : @attribute ’working-hours’ real et

– de la liste des instances : chaque ligne repr´esente une des cription, par la liste des valeurs de chacun de ses

attributs. Une valeur manquante est remplac´ee par un point d’interrogation.

Chargez un fichier arff (vous en trouverez dans /opt/weka/weka-3-4-13/data/). Si tout se passe bien, vous voyez apparaˆıtre la liste des attributs `a gauche de la fenˆetre. Cliquer sur l’un d’eux affiche un certain nombre de statistiques `a droite :

– Les valeurs minimales, maximales et moyennes pour les attr ibuts num´eriques.

– Les r´epartitions par valeur pour les attributs nominaux.

Dans les deux cas, sont calcul´es le nombre de valeurs manqua ntes, de valeurs distinctes et de valeurs uniques.

Sous ces statistiques ´el´ementaires, un petit graphique indique la r´epartition des exemples pour l’attribut courant, sous forme d’un histogramme o`u la couleur indique la proportion d’´el´ements de chaque classe dans chaque colonne.

10.2 Classify

Sous l’onglet Classify , choisissez comme classifieur weka.trees.J48 : c’est la version Weka de c4.5 (arbres de d´ecision). Choisissez ’Use training set’ pour cr´eer un arbre standard, puis ’start’ pour lancer la construction de l’arbre :

la fenˆetre ’Classifier output’ contient les r´esultats du calcul : description de l’arbre, taux d’erreurs, matrice de confusion On peut visualiser l’arbre de d´ecision en cliquant du bouto n droit, dans la fenˆetre ’Result list’, sur la derni`ere commande effectu´ee. Les r´eseaux de neurones sont dans weka.classifiers.functions.MultilayerPerceptron

Comprendre les mesures produites par un classifieur

Lorsqu’on demande `a Weka de construire un classifieur, il produit en mˆeme temps un ens emble de mesures de l’erreur estim´ee. On se propose ici d’expliquer comment sont d´efinies, calcul´ees et utilis´ees ces diff´erentes mesures, et dans quels cas on peu t en pr´ef´erer une `a une autre.

11 Les valeurs calcul´ees par Weka

La figure 7 repr´esente les statistiques que Weka retourne par d´efaut lors de la construction d’un classifieur.

12 Les mesures g´en´erales

On reprend dans cette section les premi`eres mesures donn´e es par Weka

12.1 Correctly Classified Instances

Le nombre d’exemples bien class´es, en valeur absolue, puis en pourcentage du nombre total d’exemples.

12.2 Incorrectly Classified Instances

Sous le mˆeme format, le nombre d’exemples mal class´es.

8

12.3

Kappa statistic

Le coefficient Kappa est cens´e mesur´e le degr´e de concordance de deux ou de plus ieurs juges. Dans Weka , on est toujours dans le cas de deux juges. On mesure la diff´erenc e entre l’accord constat´e entre les deux juges, et l’accord qui existerait si les juges classaient les exemp les au hasard. Dans Weka , le jugement, c’est la classe d’un exemple, et les deux juges sont le classifieur et la classe r´eelle de l’exemple. L’accord/d´esaccord entre les deux juges se lit directement dans la matrice de confusion : c’est une mesure dont la valeur est d’autant plus grande que la matrice est dia gonale. Le coefficient Kappa se calcule de la fa¸con suivante :

κ = P o P e 1 P e avec P o : La proportion de l’´echantillon sur laquelle les deux juges sont d’accord (i.e. la diagonale principale de la matrice de confusion). et

P e = i p i p .i

n

2

o`u

p i : somme des ´el´ements de la ligne i

p .i : somme des ´el´ements de la colonne i

n : taille de l’´echantillon

Sur l’exemple de la figure 7, dont la matrice de confusion ´eta it :

a b c total 50 0 0 50 0 49 1 50 0 1 49
a
b
c
total
50
0
0
50
0
49
1
50
0
1
49
50
50
50
50

total On a :

P 0 = 50 + 49 + 49 = 148

150

150 = 0 .98667

P e =

= 1

(50 × 50) + (50 × 50) + (50 × 50) 150 × 150

3

(cette valeur est constante pour tous les classifieurs sur ce t ensemble d’exemples !) et donc

κ = 0 .986667 0 .333

0 .666

= 0 .98

Le coefficient Kappa prend ses valeurs entre -1 et 1.

– Il est maximal quand les deux jugements sont les mˆemes : tous les exemples sont sur la diagonale, et P 0 = 1

– Il vaut 0 lorsque les deux jugements sont ind´ependants (P 0 = P e )

– Il vaut -1 lorsque les juges sont en total d´esaccord

Certains auteurs (Landis & Koch) ont propos´e une ´echelle de degr´e d’accord selon la valeur du coefficient :

Accord Kappa Excellent > 0.81 Bon 0.80-0.61 Mod´er´e 0.4-0.41 M´ediocre 0.4-0.21 Mauvais 0.20-0.0 Tr`es
Accord
Kappa
Excellent
> 0.81
Bon
0.80-0.61
Mod´er´e
0.4-0.41
M´ediocre
0.4-0.21
Mauvais
0.20-0.0
Tr`es mauvais
< 0

9

Quelques pages (en fran¸cais) o`u je suis all´e chercher ces informations : http://kappa.chez.tiscali.fr/

12.4 Mean absolute error

Erreur absolue en moyenne : pour chaque exemple, on calcule la diff´erence entre la probabilit´e (calcul´ee par le classifieur) pour un exemple d’appartenir `a sa v´eritable classe, et sa probabilit´e initiale d’appartenir `a la classe qui lui a ´et´e fix´ee dans l’ensemble d’exemples (en g´en´eral, cette probabilit´e vaut 1). On divise ensuite la somme de ces erreurs par le nombre d’instances dans l’ense mble d’exemples. Plus formellement :

– Soient p 1 , p 2 , · · · , p n les probabilit´es calcul´ees par le classifieur pour chaque exemple d’appartenir `a sa vrai classe.

– Soient a 1 , a 2 , · · · , a n les probabilit´es `a priori pour chaque exemple d’appartenir `a la classe qui leur a ´et´e fix´ee par d´efinition (en g´en´eral, les a i valent toujours 1, mais on peut imaginer qu’on soit un peu moins cat´egorique, et que la classe attribu´ee ne le soit qu’avec une certaine confiance).

– Alors on calcule :

Mean Absolute Error = |p 1 a 1 | + |p 2 a 2 | + · · · + |p n a n |

n

A mon avis, il y a un bug dans Weka , et le calcul r´eellement effectu´e ne correspond pas a` ce qu i est ´ecrit dans le livre. Dans le cas o`u le classifieur est un pr´edicteur, c’est-`a-dire qu’il retourne une valeur r´eelle au lieu d’une classe discr`ete, c’est la diff´erence entre la valeur calcul´ee et la valeur attendue qui sont utilis´ees pour p i et a i ; ca¸ peut par exemple ˆetre le cas pour les r´eseaux de neurones.

12.5 Root mean-squared error

Cette mesure d’erreur concerne principalement les pr´edicteurs Racine carr´ee de l’erreur quadratique moyenne : avec les mˆemes notations que ci-dessus, elle correspond `a :

(p 1 a 1 ) 2 + · · · + (p n a n ) 2

n

L’erreur quadratique avantage les solutions o`u il y a beaucoup de petits ´ecarts, par rapport `a celles qui sont exactes presque partout, mais qui font de grosses erreurs en un petit nombre de points. Le fait de prendre la racine carr´ee permet de manipuler des q uantit´es qui ont la mˆeme dimensions que les valeurs `a pr´evoir.

12.6 Relative absolute error

Cette mesure d’erreur concerne principalement les pr´edicteurs Erreur absolue relative : le nom paraˆıt tr`es mal choisi On compare l’erreur absolue avec l’erreur absolue d’un pr´edicteur tr`es simple, qui retournerait toujours la valeur moyenne des a i , soit a¯ = n i a i :

1

|p 1 a 1 | + · · · + |p n a n | |a 1 a¯ | + · · · |a n a¯ |

12.7 Root relative squared error

Cette mesure d’erreur concerne principalement les pr´edicteurs Racine carr´ee de l’erreur quadratique relative : rapport entre l’erreur quadratique et ce que serait l’erreur quadratique d’un pr´edicteur qui retournerait toujours la valeur moyenne des a i :

10

(p 1 a 1 ) 2 + · · · + (p n a n ) 2 (a 1 a¯ ) 2 + · · · (a n a¯ ) 2

13 Les mesures d’exactitude par classe

Ces valeurs se trouvent dans la partie “Detailed Accuracy By Class”. Pour chaque classe, Weka fournit cinq mesures. Pour une classe donn´ee, un classifieur, et un exemple, quatr e cas peuvent se pr´esenter :

1. L’exemple est de cette classe, et le classifieur ne se tromp e pas : c’est un vrai positif.

2. L’exemple est de cette classe, mais le classifieur se tromp e : c’est un faux n´egatif.

3. L’exemple n’est pas de cette classe, mais le classifieur la lui attribue quand mˆeme : c’est faux positif.

4. L’exemple n’est pas de cette classe, et le classifieur ne le range pas non plus dans cette classe : c’est un vrai n´egatif.

Le tableau de la figure 8 r´esume les diff´erentes situations.

13.1 TP Rate

Rapport des vrais positifs. Il correspond `a :

Nombre de vrais positifs de faux n´egatifs = Nombre de vrais positifs + Nombre

Nombre de vrais positifs Nombre d’exemples de cette classe

C’est donc le rapport entre le nombre de bien class´e et le nombre total d’´el´ements qui devraient ˆetre bien class´es. Il se calcule en utilisant la premi`ere ligne du ta bleau de la figure 8.

13.2 FP Rate

Rapport des faux positifs. Il correspond, sym´etriquement `a la d´efinition pr´ec´edente, `a :

Nombre de faux positifs vrais n´egatifs = Nombre de faux positifs + Nombre de

Nombre de faux positifs Nombre d’exemples n’´etant pas de cette classe

Il se calcule en utilisant la deuxi`eme ligne du tableau de la figure 8. La donn´ee des taux TP Rate et FP Rate permet de reconstruire la matrice de confusion pour une clas se donn´ee. Sym´etriquement, la matrice de confusion permet de calcule r TP Rate et FP Rate . Prenons l’exemple de la figure 7 :

– Les cinquante exemples de classe Iris-setosa sont bien class´es (pas de faux n´egatifs) : donc TP Rate =1.

– 49 iris-versicolor sont bien class´es, mais le dernier est mal class´e : TP Rate = 49 = 0 .98

50

– 2 exemples sont class´es `a tort parmi les Iris-versicolor , mais 98 exemples, qui ne sont pas des

2

Iris-versicolor , n’ont pas ´et´e reconnus comme tels : FP Rate = 98 = 0 .0204

– Un exemple est class´e `a tort parmi les Iris-virginica , pour 99 autres sur lesquels on ne s’est pas tromp´e :

FP

Rate = 1 = 0 .0101

99

– 48 iris-virginica sont bien class´es, sur un total de 50 : TP Rate = 48 50 = 0 .96

Les notions de Precision , Recall , et F-Measure se rencontre plutˆot dans le domaine de la classification de textes. Les algorithmes de classification de textes peuvent ˆetre utilis´es pour trouver tous les articles susceptibles d’int´eresser leur utilisateur. Il est alors important de s avoir :

11

– Si tous les articles int´eressants ont ´et´e trouv´es, si o n n’en a pas oubli´e.

– Si tous les articles propos´es `a l’utilisateur sont pertinents. Combien lui en a-t-on propos´es qui en fait ne l’int´eresseront pas ? La premi`ere notion est couverte par Recall , et correspond aussi exactement `a TP Rate . La seconde correspond `a Precision . On souhaite parfois obtenir une mesure globale regroupant ces deux valeurs : on d´efinit alors la F-Measure

13.3 Precision

C’est le rapport entre le nombre de vrais positifs et la somme des vrais positifs et des faux positifs (la premi`ere colonne du tableau de la figure 8). Une valeur de 1 exprime le fait que tous les exemples class´es positifs l’´etaient vraiment.

13.4 Recall

Un Recall de 1 signifie que tous les exemples positifs ont ´et´e trouv´e s.

13.5 F-Measure

Cette quantit´e permet de regrouper en un seul nombre les per formances du classifieur (pour une classe donn´ee) pour ce qui concerne le Recall et la Precision :

F-Measure = 2 × Recall × Precision Recall + Precision

12

import weka.core.Instances; import weka.core.Instance; import weka.core.Attribute; import weka.core.FastVector; import weka.classifiers.Classifier; import weka.classifiers.trees.J48; import java.util.Enumeration; import java.util.Random; public class Exemple{ public static void main(String argv[])throws Exception{ Random generateur=new Random(); // D´efinition du premier attribut FastVector valAttribut1=new FastVector(2); valAttribut1.addElement("pluie"); valAttribut1.addElement("soleil"); Attribute att1=new Attribute("meteo",valAttribut1); // D´efinition du deuxi`eme attribut Attribute att2=new Attribute("Temperature"); // D´efinition de la classe FastVector valClasse=new FastVector(2); valClasse.addElement("vrai"); valClasse.addElement("faux"); Attribute classe=new Attribute("d´ecision",valClasse); // Un vecteur pour regrouper les attributs FastVector rassemble=new FastVector(3);

rassemble.addElement(att1);

rassemble.addElement(att2);

rassemble.addElement(classe); // d´efinition de l’ensemble d’apprentissage Instances dataset=new Instances("exemple",rassemble,1000); dataset.setClass(classe); // Cr´eer des exemples // d’abord 500 exemples de pluie for(int i=0;i<500;i++){ Instance element=new Instance(3);

element.setValue(att1,"pluie");

double u=generateur.nextDouble();

element.setValue(att2,u);

if(u<0.5) element.setValue(classe,"vrai"); else element.setValue(classe,"faux"); element.setDataset(dataset); dataset.add(element); } // Puis 500 exemples de soleil for(int i=0;i<500;i++){ Instance element=new Instance(3);

element.setValue(att1,"soleil");

element.setValue(att2,generateur.nextDouble());

element.setValue(classe,"vrai"); element.setDataset(dataset); dataset.add(element); } // Aller chercher un classifieur (arbre de d´ecision) Classifier arbre=new J48(); // Construire l’arbre arbre.buildClassifier(dataset);

// Imprimer les r´esultats System.out.println(arbre); // parcourir l’ensemble des exemples, les afficher, ainsi que leur classification int good=0,bad=0; Enumeration e=dataset.enumerateInstances();

while(e.hasMoreElements()){

13

Instance i=(Instance)e.nextElement(); if (arbre.classifyInstance(i)!=i.value(dataset.class Attribute())) bad++; else good++;

}

System.out.println("Bien class´es : "+good+" Mal class´es : "+bad);

}}

Fig. 1 – Un exemple complet

Fig. 2 – La fenˆetre principale de l’Explorer @relation ’labor-neg-data’ @attribute ’duration’ real

Fig. 2 – La fenˆetre principale de l’Explorer

@relation ’labor-neg-data’ @attribute ’duration’ real @attribute ’wage-increase-first-year’ real @attribute ’wage-increase-second-year’ real @attribute ’wage-increase-third-year’ real @attribute ’cost-of-living-adjustment’ {’none’,’tcf’,’tc’} @attribute ’working-hours’ real @attribute ’pension’ {’none’,’ret_allw’,’empl_contr’} @attribute ’standby-pay’ real @attribute ’shift-differential’ real @attribute ’education-allowance’ {’yes’,’no’} @attribute ’statutory-holidays’ real @attribute ’vacation’ {’below_average’,’average’,’generous’} @attribute ’longterm-disability-assistance’ {’yes’,’no’} @attribute ’contribution-to-dental-plan’ {’none’,’half’,’full’} @attribute ’bereavement-assistance’ {’yes’,’no’} @attribute ’contribution-to-health-plan’ {’none’,’half’,’full’} @attribute ’class’ {’bad’,’good’} @data

1,5,?,?,?,40,?,?,2,?,11,’average’,?,?,’yes’,?,’good’

2,4.5,5.8,?,?,35,’ret_allw’,?,?,’yes’,11,’below_average’,?,’full’,?,’full’,’good’

?,?,?,?,?,38,’empl_contr’,?,5,?,11,’generous’,’yes’,’half’,’yes’,’half’,’good’

3,3.7,4,5,’tc’,?,?,?,?,’yes’,?,?,?,?,’yes’,?,’good’

Fig. 3 – Le d´ebut d’un fichier ARFF

14

=== Evaluation on training set === === Summary ===

Correctly Classified Instances

 

148

98.6667 %

Incorrectly Classified Instances

2

1.3333 %

Kappa statistic

0.98

Mean absolute error

0.0248

Root mean squared error

0.0911

Relative absolute error

5.5779 %

Root relative squared error

19.3291 %

Total Number of Instances

150

=== Detailed Accuracy By Class ===

TP Rate

FP Rate

Precision

Recall

F-Measure

Class

1

0

1

1

1

Iris-setosa

0.98

0.01

0.98

0.98

0.98

Iris-versicolor

0.98

0.01

0.98

0.98

0.98

Iris-virginica

=== Confusion Matrix ===

a

b

c

<-- classified as

50

0

0

|

a = Iris-setosa

0 49

1

|

b = Iris-versicolor

0

1 49

|

c = Iris-virginica

Fig. 4 – Statistiques de Weka

Classe pr´edite pr´edite non pr´edite
Classe pr´edite
pr´edite
non pr´edite
Exemples de cette classe Vrais positifs Faux n´egatifs Exemple n’appartenant pas a` cette classe Faux
Exemples de cette classe
Vrais positifs
Faux n´egatifs
Exemple n’appartenant pas a` cette classe Faux positifs
Vrais n´egatifs

Fig. 5 – Les quatre cas pour une classification binaire

15