Transcript TP, étude de plusieurs critères dévaluations

M1 Informatique UMI2C
Fouille de données et Apprentissage
TP
Alexis Lechervy
[email protected]
17/03/2014
1
Introduction
L’objectif de ce TP est de classer une base de donnée radar. Ce TP sera réalisé en python 2.7 à
l’aide de la bibliothèque scikit-learn. Une documentation complète de cette bibliothèque est disponible
à l’adresse http://scikit-learn.org.
La base de donnée que vous étudierez est la base Ionosphere (http://archive.ics.uci.edu/ml/
datasets/Ionosphere). Vous pouvez la télécharger sur la page web de la base de donné (http://
archive.ics.uci.edu/ml/machine-learning-databases/ionosphere/ionosphere.data).
La base Ionosphere contient 351 mesures radars. Chaque mesure est décrite par un descripteur de 34
dimensions. L’objectif est de détecter la présence ou non d’électron libre dans la ionosphère. Pour plus
de détail sur la base, vous pourrez vous référer à la description donnée par la page web de cette dernière.
2
2.1
Lecture de la base de donnée
Lecture des fichiers
Nous allons dans cette partie lire les données de la base de donnée. Commencez par télécharger le
fichier de la base. Ce fichier contient une ligne par exemple et 35 colonnes pour le décrire. La dernière
colonne est une lettre donnant la classe de l’exemple, ’g’ pour good et ’b’ pour bad. Vous pouvez utiliser
le code suivant pour lire les données de la base de donnée :
import numpy a s np
data = np . g e n f r o m t x t ( ’ i o n o s p h e r e . data ’ , d e l i m i t e r=” , ” , dtype= ’ | S5 ’ )
X = data [ : , 0 : − 1 ] . a s t y p e ( f l o a t )
y = ( data [: , −1]== ’ g ’ ) . a s t y p e ( i n t )
Vérifiez que vous avez la bonne taille pour la base de donnée et pour le nombre d’attribut des
exemples.
2.2
Découpage en un ensemble d’entrainement et un de test
La base de donnée contient un unique ensemble de donnée contenant toutes les données. Il va falloir
construire au moins deux ensembles distincts, l’un pour entrainer notre classifieur et l’autre pour le
tester.
Le code suivant permet de créer ces deux ensembles de manière équilibré (autant d’image dans
l’ensemble d’entrainement que dans l’ensemble de test) :
from s k l e a r n . c r o s s v a l i d a t i o n import t r a i n t e s t s p l i t
t r a i n , t e s t , y t r a i n , y t e s t = t r a i n t e s t s p l i t (X, y , t e s t s i z e =0.5 , r a n d o m s t a t e =0)
Modifier le code précédent afin d’avoir 2/3 des exemples pour l’entrainement et 1/3 pour le test.
Vérifier que les deux ensembles que vous avez créer ont le bon nombre d’exemple.
1
3
Comparaison de différent critère d’évaluation des performances
Nous allons tester dans cette partie plusieurs critère d’évaluation des performances d’un algorithme
d’apprentissage de type SVM.
Commencez par apprendre un SVM linéaire sur vos données d’apprentissage.
Nous allons maintenant évaluer les performances de ce SVM sur la base de test. Nous allons pour
cela utiliser différentes mesures de performances. Vous importerez le module metrics de scikit-learn :
from s k l e a r n . m e t r i c s import ∗
Pour chacune des méthodes d’évaluation que vous testerez, n’oubliez pas de vérifier si vous connaissez
bien la formule mathématique qui lui est associé.
3.1
Le nombre d’erreur de classification
Le premier critère que nous allons calculer, est le nombre moyenne d’erreur de notre classifieur. Pour
cela commencez par calculer les labels prédits par votre SVM sur les données de test (utilisez la méthode
predict du SVM). Puis calculer la proportion d’erreur à l’aide de la fonction
accuracy score ( y test , y pred )
Votre classifieur donne-t-il de bonne performance ?
3.2
La matrice de confusion
La matrice de confusion d’un problème de classification est une matrice représentant la performance
de classification d’un algorithme multi-classe pour chacune des classes. Chaque ligne représente une classe
réelle tandis que chaque colonne représente le nombre d’exemple classé par le classifieur dans cette classe.
Par exemple si la valeur de la case à la ligne 2, colonne 3 est 12, il y a 12 exemples de la classe 2 qui
ont été attribué à la classe 3. L’objectif est d’avoir que des valeurs sur la diagonale et des zéros partout
ailleurs. Calculez la matrice de confusion avec le code suivant :
confusion matrix ( y test , y pred )
Que pouvez vous dire sur votre algorithme en regardant les valeurs de cette matrice.
3.3
L’aire sous la courbe ROC
Affichez la courbe ROC (vous pouvez réutiliser le code du TP précédent). Calculez l’aire sous la
courbe à l’aide de la fonction auc (comme dans le TP précédent). Comparez la valeur trouvée au résultat
de la fonction.
roc auc score ( y test , score pred )
Faites bien attention à utiliser la valeur de la fonction de décision et non le label prédit que nous
venons d’utiliser pour les deux premières méthodes d’évaluation.
3.4
L’aire sous la courbe de précision/rappel
Affichez la courbe de précision/rappel. Le code est très similaire à celui de la courbe ROC, il faut juste
utiliser la fonction precision recall curve au lieu de roc curve. Calculez l’aire sous la courbe et comparez
la valeur trouvée au résultat de la fonction
average precision score ( y test , score pred )
2
4
Cross-validation des paramètres de l’algorithme d’apprentissage
Nous allons maintenant nous intéresser à trouver le meilleur jeu de paramètre pour notre SVM. Nous
allons tester différent type de noyaux ainsi que différentes valeurs de paramètres.
Pour cela nous aurons besoin d’utiliser d’ensembles de validation pour trouver les meilleurs paramètres. Pour réaliser cela, nous nous appuierons sur la classe GridSearchCV. Étudiez le code suivant,
trouvant les meilleurs paramètres parmi une liste de valeurs possibles pour optimiser un classifieur selon
le nombre d’erreur de classification :
from s k l e a r n . g r i d s e a r c h import GridSearchCV
t u n e d p a r a m e t e r s = [ { ’ k e r n e l ’ : [ ’ r b f ’ ] , ’gamma ’ : [ 1 e −1, 1 e −2, 1 e −3, 1 e −4] ,
’C ’ : [ 1 e −2 ,1 e −1 ,1 , 1 0 , 1 0 0 , 1 0 0 0 ] } ,
{ ’ k e r n e l ’ : [ ’ l i n e a r ’ ] , ’C ’ : [ 1 e −2 ,1 e −1 ,1 , 1 0 , 1 0 0 , 1 0 0 0 ] } ]
c l f g r i d = GridSearchCV (SVC( p r o b a b i l i t y=True ) ,
t u n e d p a r a m e t e r s , cv =5, s c o r i n g= ’ a c c u r a c y ’ )
c l f g r i d . f i t ( train , y train )
print ( ” Best p a r a m e t e r s s e t found on development s e t : ” )
print ( c l f g r i d . b e s t e s t i m a t o r )
print ( ” Grid s c o r e s on development s e t : ” )
def comp ( v1 , v2 ) :
i f v1 [ 2 ] . mean()< v2 [ 2 ] . mean ( ) :
return −1
e l i f v1 [ 2 ] . mean()> v2 [ 2 ] . mean ( ) :
return 1
else :
return 0
f o r params , mean score , s c o r e s in s o r t e d ( c l f g r i d . g r i d s c o r e s , comp ) :
print ( ” %0.3 f (+/−%0.03 f ) f o r %r ”% ( mean score , s c o r e s . s t d ( ) / 2 , params ) )
Est-ce que tout les jeux de paramètre sont équivalent ? Y-a-t il une combinaison meilleure que les
autres ?
Testez une cross validation selon un autre critère de performance. Vous pouvez utiliser par exemple,
l’aire sous la courbe de précision/rappel (’average precision’) ou l’aire sous la courbe ROC (’roc auc’).
Selon ces différents critères, trouvez vous toujours les même jeux de paramètres optimales ?
Testez maintenant les paramètres optimaux que vous venez de trouver sur les données de test. Quels
sont les performances que vous obtenez ?
3