TP sur la classification supervisée (introduction)(8 juin 2018)

1. Utilisation de ScikitLearn avec Python 3

On suppose ici que anaconda(3) est installé.Nous utiliserons la librairie ScikitLearn de Python 3.Nous importons d’abord les librairies utiles :

import numpy as npimport matp lo t l i bimport matp lo t l i b . pyplot as p l t

2. Expériences de reconnaissance de chiffres manuscrits

2.1 Chargement de la base de données MNIST

Pour nos premières expériences, nous allons utiliser la base de données MNIST qui comporte lesdescriptions de chiffres manuscrits en format 28 × 28, soit 784 pixels, et les étiquettes associées.La base contient en tout 70 000 exemples, c’est-à-dire 7000 exemples de chaque chiffre.Nous chargeons d’abord la base, puis nous examinons l’un des exemples qu’elle contient.

>>> from sk l e a rn . da ta s e t s import fetch_mldata

>>> mnist = fetch_mldata ( ’MNIST o r i g i n a l ’ )

>>> mnistOut [ 8 ] :{ ’COL_NAMES’ : [ ’ l a b e l ’ , ’ data ’ ] ,

’DESCR’ : ’ mldata . org datase t : mnist−o r i g i n a l ’ ,’ data ’ : array ( [ [ 0 , 0 , 0 , . . . , 0 , 0 , 0 ] ,

[ 0 , 0 , 0 , . . . , 0 , 0 , 0 ] ,[ 0 , 0 , 0 , . . . , 0 , 0 , 0 ] ,. . . ,[ 0 , 0 , 0 , . . . , 0 , 0 , 0 ] ,[ 0 , 0 , 0 , . . . , 0 , 0 , 0 ] ,[ 0 , 0 , 0 , . . . , 0 , 0 , 0 ] ] , dtype=uint8 ) ,

’ t a r g e t ’ : array ( [ 0 . , 0 . , 0 . , . . . , 9 . , 9 . , 9 . ] ) }

>>> X, y = mnist [ "data" ] , mnist [ " t a r g e t " ]

>>> X. shapeOut [ 1 0 ] : (70000 , 784)>>> y . shapeOut [ 1 2 ] : (70000 , )

1

>>> %matp lo t l i b i n l i n e

>>> import matp lo t l i b

>>> import matp lo t l i b . pyplot as p l t

>>> some_digit = X[36000 ]

>>> some_digit_image = some_digit . reshape (28 , 28)

>>> p l t . imshow ( some_digit_image , cmap = matp lo t l i b . cm . binary , i n t e r p o l a t i o n=" nea r e s t " )

La dernière instruction devrait produire une image telle que :

Figure 1 – Un exemple de ‘5’ de la base MNIST.

La figure 2 montre un échantillon de chiffres contenus dans la base MNIST.

2.2 Premier apprentissage

Nous sélectionnons 60 000 exemples pour l’apprentissage et 10 000 pour le test (la base MNISTest organisée de cette manière).Pour les tests à venir, il est important de garantir que les exemples sont aléatoirement répartisdans la base d’apprentissage afin que tout tirage d’un sous-ensemble comporte à peu près lamême proportion de chaque chiffre.

>>> X_train , X_test , y_train , y_test = X[ : 6 0 0 0 0 ] , X[ 6 0 0 0 0 : ] , y [ : 6 0 0 0 0 ] , y [ 6 0 0 0 0 : ]

>>> shu f f l e_ index = np . random . permutation (60000)

>>> X_train , y_train = X_train [ shu f f l e_ index ] , y_train [ shu f f l e_ index ]

Nous allons d’abord apprendre des classifieurs binaires, à deux classes. Ici, nous choisissonsd’entraîner un classifieur à apprendre à reconnaître les 5 contre tous les autres chiffres.

>>> y_train_5 = ( y_train == 5)>>> y_test_5 = ( y_test == 5)

>>> from sk l e a rn . l inear_model import SGDClass i f i e r

2

Figure 3-1. A few digits from the MNIST dataset

But wait! You should always create a test set and set it aside before inspecting the data closely. TheMNIST dataset is actually already split into a training set (the first 60,000 images) and a test set (the last10,000 images):

X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]

Let’s also shuffle the training set; this will guarantee that all cross-validation folds will be similar (you

Figure 2 – Un échantillon de chiffres de la base MNIST.

>>> sgd_cl f = SGDClass i f i e r ( random_state=42)/Users / an t o i n e c o rnue j o l s /anaconda3/ l i b /python3 .6/ s i t e −packages / sk l e a rn /l inear_model / s to cha s t i c_grad i en t . py : 8 4 : FutureWarning : max_iter and t o lparameters have been added in<c l a s s ’ s k l e a rn . l inear_model . s t o cha s t i c_grad i en t . SGDClass i f i e r ’>

in 0 . 1 9 . I f both are l e f t unset , they d e f au l t to max_iter=5 and t o l=None .I f t o l i s not None , max_iter d e f a u l t s to max_iter=1000.From 0 .21 , d e f au l t max_iter w i l l be 1000 , and de f au l t t o l w i l l be 1e−3."and de f au l t t o l w i l l be 1e−3." % type ( s e l f ) , FutureWarning )

Nous avons chargé un classifieur linéaire binaire avec descente de gradient stochastique.Ici, par défaut, l’apprentissage s’arrête après 1000 itérations maximum ou bien quand la pro-gression de l’erreur d’apprentissage d’une itération à la suivante vaut moins que 10−3.Voir l’url :http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.htmlpour les détails du paramétrage de cette fonction.

Nous entrainons ensuite le classifieur sur les données d’apprentissage, et nous le testons surl’exemple de 5 déjà vu (some_digit).

>>> sgd_cl f . f i t ( X_train , y_train_5 )Out [ 6 8 ] :SGDClass i f i e r ( alpha =0.0001 , average=False , c lass_weight=None , e p s i l o n =0.1 ,

eta0 =0.0 , f i t_ i n t e r c e p t=True , l 1_rat i o =0.15 ,l ea rn ing_rate=’ optimal ’ , l o s s=’ hinge ’ , max_iter=5, n_iter=None ,n_jobs=1, pena l ty=’ l 2 ’ , power_t=0.5 , random_state=42, s h u f f l e=True ,t o l=None , verbose =0, warm_start=False )

3

>>> sgd_cl f . p r ed i c t ( [ some_digit ] )Out [ 6 9 ] : array ( [ True ] , dtype=bool )

Le classifieur appris classe bien cet exemple là (qui faisait partie de l’ensemble d’apprentissage).Mais, bien sûr, il faut avoir une démarche plus systématique pour évaluer la qualité du classifieurappris.

3. Évaluation des performances

Une méthode courante d’évaluation d’un apprentissage supervisé de concept est la validationcroisée. Ici, nous utilisons une validation croisée à trois plis. Une valeur courante est 10 plis.La fonction cross_val_score calcule les erreurs associées à chaque pli. Vous pouvez ensuite encalculer la moyenne.

>>> from sk l e a rn . mode l_se lect ion import cross_val_score

>>> cross_val_score ( sgd_clf , X_train , y_train_5 , cv=3, s c o r i ng=" accuracy " )Out [ 7 1 ] : array ( [ 0 .9654 , 0 .9634 , 0 . 9 6 615 ] )

Ces taux de bonne prédiction paraissent tout à fait impressionnants pour un apprentissage parune méthode linéaire.

Mais que ferait un classifieur qui se contenterait de toujours prédire not 5 ?

>>> from sk l e a rn . base import BaseEstimator

c l a s s Nev e r 5C l a s s i f i e r ( BaseEstimator ) :de f f i t ( s e l f , X, y=None ) :

passde f p r ed i c t ( s e l f , X) :

r e turn np . z e r o s ( ( l en (X) , 1 ) , dtype=bool )

>>> never_5_clf = Nev e r 5C l a s s i f i e r ( )

>>> cross_val_score ( never_5_clf , X_train , y_train_5 , cv=3, s c o r i ng=" accuracy " )Out [ 8 0 ] : array ( [ 0 .91295 , 0 .9094 , 0 .9066 ] )

Pas très étonnant. Mais cela relativise la performance apparemment excellente du classifieurlinéaire !

3.1 Matrice de confusion

On calcule la matrice de confusion.

>>> from sk l e a rn . mode l_se lect ion import cross_val_pred ict

>>> y_train_pred = cross_val_pred ict ( sgd_clf , X_train , y_train_5 , cv=3)

4

>>> from sk l e a rn . met r i c s import confusion_matrix

>>> confusion_matrix ( y_train_5 , y_train_pred )Out [ 8 4 ] :array ( [ [ 5 3 7 7 9 , 800 ] ,

[ 1301 , 4 1 2 0 ] ] )

Puis celle que l’on obtiendrait avec un classifieur parfait (qui prédit la classe donnée par la based’exemples).

>>> y_tra in_per fec t_pred ic t ions = y_train_5

>>> confusion_matrix ( y_train_5 , y_tra in_per fec t_pred ic t ions )Out [ 8 6 ] :array ( [ [ 5 4 5 7 9 , 0 ] ,

[ 0 , 5 4 2 1 ] ] )

3.2 Précision et rappel

>>> from sk l e a rn . met r i c s import prec i s i on_score , r e c a l l_ s c o r e

>>> prec i s i on_sco r e ( y_train_5 , y_train_pred )Out [ 8 8 ] : 0 .83739837398373984

>>> re c a l l_ s c o r e ( y_train_5 , y_train_pred )Out [ 8 9 ] : 0 .76000737871241464

>>> from sk l e a rn . met r i c s import f1_score

>>> f1_score ( y_train_5 , y_train_pred )Out [ 9 1 ] : 0 .79682815975244181

Le compromis précision vs. rappel

>>> y_scores = sgd_cl f . d e c i s i on_func t i on ( [ some_digit ] )

>>> y_scoresOut [ 1 4 2 ] : array ( [ 208807 .27906182 ] )

>>> thre sho ld = 0

>>> y_some_digit_pred = ( y_scores > thre sho ld )

>>> y_some_digit_predOut [ 1 4 5 ] : array ( [ True ] , dtype=bool )

>>> thre sho ld = 210000

>>> y_some_digit_pred = ( y_scores > thre sho ld )

5

>>> y_some_digit_predOut [ 1 4 8 ] : array ( [ Fa l se ] , dtype=bool )

>>> y_scores = cross_val_pred ict ( sgd_clf , X_train , y_train_5 , cv=3,method=" dec i s i on_func t i on " )

>>> from sk l e a rn . met r i c s import p r e c i s i on_reca l l_curve

>>> y_scores . shapeOut [ 1 0 6 ] : (60000 , 2)

>>> pr e c i s i o n s , r e c a l l s , t h r e sho ld s = prec i s i on_reca l l_curve ( y_train_5 , y_scores [ : , 1 ] )

de f p lo t_prec i s i on_reca l l_vs_thresho ld ( p r e c i s i o n s , r e c a l l s , t h r e sho ld s ) :p l t . p l o t ( thre sho lds , p r e c i s i o n s [ : −1 ] , "b−−" , l a b e l=" Pr e c i s i on " , l i n ew id th =2)p l t . p l o t ( thre sho lds , r e c a l l s [ : −1 ] , "g−" , l a b e l=" Reca l l " , l i n ew id th =2)p l t . x l ab e l ( "Threshold " , f o n t s i z e =16)p l t . l egend ( l o c="upper l e f t " , f o n t s i z e =16)p l t . yl im ( [ 0 , 1 ] )

>>> p l t . f i g u r e ( f i g s i z e =(8 , 4 ) )Out [ 1 0 9 ] : <matp lo t l i b . f i g u r e . Figure at 0x1a1c8d8c50><matp lo t l i b . f i g u r e . Figure at 0x1a1c8d8c50>

>>> plot_prec i s i on_reca l l_vs_thresho ld ( p r e c i s i o n s , r e c a l l s , t h r e sho ld s )

Vous devriez obtenir une figure telle que la figure 3.

This confirms that raising the threshold decreases recall. The image actually represents a 5, and theclassifier detects it when the threshold is 0, but it misses it when the threshold is increased to 200,000.

So how can you decide which threshold to use? For this you will first need to get the scores of allinstances in the training set using the cross_val_predict() function again, but this time specifying thatyou want it to return decision scores instead of predictions:

y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3, method="decision_function")

Now with these scores you can compute precision and recall for all possible thresholds using theprecision_recall_curve() function:

from sklearn.metrics import precision_recall_curve

precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)

Finally, you can plot precision and recall as functions of the threshold value using Matplotlib (Figure 3-4):

def plot_precision_recall_vs_threshold(precisions, recalls, thresholds): plt.plot(thresholds, precisions[:-1], "b--", label="Precision") plt.plot(thresholds, recalls[:-1], "g-", label="Recall") plt.xlabel("Threshold") plt.legend(loc="upper left") plt.ylim([0, 1])

plot_precision_recall_vs_threshold(precisions, recalls, thresholds)plt.show()

Figure 3-4. Precision and recall versus the decision threshold

Figure 3 – Illustration du compromis précision vs. rappel en fonction du seuil de décision.

Il est également intéressant de tracer la figure précision en fonction du rappel (voir figure 4).

3.3 Courbe ROC

6

NOTEYou may wonder why the precision curve is bumpier than the recall curve in Figure 3-4. The reason is that precision maysometimes go down when you raise the threshold (although in general it will go up). To understand why, look back at Figure 3-3and notice what happens when you start from the central threshold and move it just one digit to the right: precision goes from 4/5(80%) down to 3/4 (75%). On the other hand, recall can only go down when the threshold is increased, which explains why itscurve looks smooth.

Now you can simply select the threshold value that gives you the best precision/recall tradeoff for yourtask. Another way to select a good precision/recall tradeoff is to plot precision directly against recall, asshown in Figure 3-5.

Figure 3-5. Precision versus recall

You can see that precision really starts to fall sharply around 80% recall. You will probably want toselect a precision/recall tradeoff just before that drop — for example, at around 60% recall. But ofcourse the choice depends on your project.

So let’s suppose you decide to aim for 90% precision. You look up the first plot (zooming in a bit) and

Figure 4 – Précision en fonction du rappel.

>>> my_y_scores = y_scores [ : , 1 ]

>>> from sk l e a rn . met r i c s import roc_curve

>>> fpr , tpr , t h r e sho ld s = roc_curve ( y_train_5 , my_y_scores )

de f plot_roc_curve ( fpr , tpr , l a b e l=None ) :p l t . p l o t ( fpr , tpr , l i n ew id th =2, l a b e l=l a b e l )p l t . p l o t ( [ 0 , 1 ] , [ 0 , 1 ] , ’ k−− ’ )p l t . ax i s ( [ 0 , 1 , 0 , 1 ] )p l t . x l ab e l ( ’ Fa l se Po s i t i v e Rate ’ , f o n t s i z e =16)p l t . y l ab e l ( ’ True Po s i t i v e Rate ’ , f o n t s i z e =16)

>>> p l t . f i g u r e ( f i g s i z e =(8 , 6 ) )Out [ 1 3 6 ] : <matp lo t l i b . f i g u r e . Figure at 0 x1a1 f8e f 5 f 8 ><matp lo t l i b . f i g u r e . Figure at 0 x1a1 f8e f5 f 8 >

>>> plot_roc_curve ( fpr , tpr )

Vous devriez obtenir une courbe de la forme de celle de la figure 5.

4. Apprentissage sur les donnés « Titanic »

Le but de cet apprentissage est d’induire une règle de décision sur la survie ou non des passa-gers (colonne survived de valeur 0 (n’a pas survécu) ou 1 (a survécu)) en s’appuyant sur desdescripteurs tels que : {âge, sexe, la classe de passager (première, seconde, troisième), le lieud’embarquement (C = Cherbourg, Q = Queenstown, S = Southampton), ... }.

>>> train_data = load_titanic_data ( "/Users / an t o i n e c o rnue j o l s / sc ik i t_learn_data /mldata/ t i t an i c_ t r a i n . csv " )

>>> test_data = load_titanic_data ( "/Users / an t o i n e c o rnue j o l s / sc ik i t_learn_data /

7

Figure 3-6. ROC curve

Once again there is a tradeoff: the higher the recall (TPR), the more false positives (FPR) the classifierproduces. The dotted line represents the ROC curve of a purely random classifier; a good classifier staysas far away from that line as possible (toward the top-left corner).

One way to compare classifiers is to measure the area under the curve (AUC). A perfect classifier willhave a ROC AUC equal to 1, whereas a purely random classifier will have a ROC AUC equal to 0.5.Scikit-Learn provides a function to compute the ROC AUC:

>>> from sklearn.metrics import roc_auc_score>>> roc_auc_score(y_train_5, y_scores)0.97061072797174941

TIPSince the ROC curve is so similar to the precision/recall (or PR) curve, you may wonder how to decide which one to use. As arule of thumb, you should prefer the PR curve whenever the positive class is rare or when you care more about the falsepositives than the false negatives, and the ROC curve otherwise. For example, looking at the previous ROC curve (and the ROCAUC score), you may think that the classifier is really good. But this is mostly because there are few positives (5s) compared tothe negatives (non-5s). In contrast, the PR curve makes it clear that the classifier has room for improvement (the curve could be

Figure 5 – Courbe ROC.

mldata/ t i t a n i c_ t e s t . csv " )

>>> train_data . shapeOut [ 2 1 3 ] : (891 , 12)

>>> test_data . shapeOut [ 2 1 4 ] : (418 , 11)

>>> train_data . head ( )Out [ 2 1 6 ] :

PassengerId Survived Pc la s s \0 1 0 31 2 1 12 3 1 33 4 1 14 5 0 3

Name Sex Age SibSp\0 Braund , Mr . Owen Harr i s male 22 .0 11 Cumings , Mrs . John Bradley ( Florence Br iggs Th . . . f emale 38 .0 12 Heikkinen , Miss . Laina female 26 .0 03 Fut r e l l e , Mrs . Jacques Heath ( L i l y May Peel ) female 35 .0 14 Allen , Mr . William Henry male 35 .0 0

Parch Ticket Fare Cabin Embarked0 0 A/5 21171 7 .2500 NaN S1 0 PC 17599 71.2833 C85 C2 0 STON/O2 . 3101282 7 .9250 NaN S3 0 113803 53.1000 C123 S4 0 373450 8 .0500 NaN S

>>> train_data . i n f o ( )<c l a s s ’ pandas . core . frame . DataFrame ’>RangeIndex : 891 en t r i e s , 0 to 890

8

Data columns ( t o t a l 12 columns ) :PassengerId 891 non−nu l l in t64Survived 891 non−nu l l in t64Pc la s s 891 non−nu l l in t64Name 891 non−nu l l ob j e c tSex 891 non−nu l l ob j e c tAge 714 non−nu l l f l o a t 6 4SibSp 891 non−nu l l in t64Parch 891 non−nu l l in t64Ticket 891 non−nu l l ob j e c tFare 891 non−nu l l f l o a t 6 4Cabin 204 non−nu l l ob j e c tEmbarked 889 non−nu l l ob j e c tdtypes : f l o a t 6 4 ( 2 ) , in t64 ( 5 ) , ob j e c t (5 )memory usage : 83.6+ KB

>>> train_data . d e s c r i b e ( )Out [ 2 1 8 ] :

PassengerId Survived Pc la s s Age SibSp \count 891.000000 891.000000 891.000000 714.000000 891.000000mean 446.000000 0.383838 2.308642 29.699118 0.523008std 257.353842 0.486592 0.836071 14.526497 1.102743min 1.000000 0.000000 1.000000 0.420000 0.00000025% 223.500000 0.000000 2.000000 20.125000 0.00000050% 446.000000 0.000000 3.000000 28.000000 0.00000075% 668.500000 1.000000 3.000000 38.000000 1.000000max 891.000000 1.000000 3.000000 80.000000 8.000000

Parch Farecount 891.000000 891.000000mean 0.381594 32.204208std 0.806057 49.693429min 0.000000 0.00000025% 0.000000 7.91040050% 0.000000 14.45420075% 0.000000 31.000000max 6.000000 512.329200

Identifiez les descripteurs et, parmi eux, les descripteurs pour lesquels existent des valeursmanquantes.

Les attributs « âge », « Cabin » et « embarked » ont des valeurs manquantes, particulièrementl’attribut « cabin » (77%). Nous allons ignorer cet attribut dans la suite. L’attribut « âge »a environ 19% de valeurs manquantes. Il faut donc remplacer ces valeurs (on utilise le termed’imputation). Ici, nous décidons de les remplacer par la valeur moyenne des âges.Finalement, les attributs « Name » et « Ticket » apportent peut-être de l’information, mais ilsont des valeurs catégorielles et non numériques. Pour le moment, nous allons les ignorer.

Regardons combien de passagers ont survécu (dans l’ensemble d’apprentissage), quelle est larépartition des passagers dans les trois classes, et la répartition entre sexes.

9

>>> train_data [ " Survived " ] . value_counts ( )Out [ 2 2 0 ] :0 5491 342Name : Survived , dtype : in t64

>>> train_data [ " Pc la s s " ] . value_counts ( )Out [ 2 2 1 ] :3 4911 2162 184Name : Pclass , dtype : in t64

>>> train_data [ "Sex" ] . value_counts ( )Out [ 2 2 2 ] :male 577female 314Name : Sex , dtype : in t64

Étudiez la répartition des ports d’embarquement.

L’appel suivant remplace les valeurs manquantes de l’attribut « âge » par la valeur moyenne decet attribut dans la base d’apprentissage.

>>> num_pipeline . f i t_trans fo rm ( train_data )Out [ 2 4 5 ] :array ( [ [ 22 . , 1 . , 0 . , 7 .25 ] ,

[ 38 . , 1 . , 0 . , 7 1 . 2 833 ] ,[ 26 . , 0 . , 0 . , 7 .925 ] ,. . . ,[ 28 . , 1 . , 2 . , 23 .45 ] ,[ 26 . , 0 . , 0 . , 30 . ] ,[ 32 . , 0 . , 0 . , 7 .75 ] ] )

La fonction MostFrequentImputer remplace les valeurs manquantes des attributs catégorielspar la valeur la plus fréquente de cet attribut dans la base d’apprentissage.

>>> cat_p ipe l ine . f i t_trans fo rm ( train_data )Out [ 2 4 7 ] :array ( [ [ 0 . , 0 . , 1 . , . . . , 0 . , 0 . , 1 . ] ,

[ 1 . , 0 . , 0 . , . . . , 1 . , 0 . , 0 . ] ,[ 0 . , 0 . , 1 . , . . . , 0 . , 0 . , 1 . ] ,. . . ,[ 0 . , 0 . , 1 . , . . . , 0 . , 0 . , 1 . ] ,[ 1 . , 0 . , 0 . , . . . , 1 . , 0 . , 0 . ] ,[ 0 . , 0 . , 1 . , . . . , 0 . , 1 . , 0 . ] ] )

>>> X_train = prep roce s s_p ipe l i n e . f i t_trans fo rm ( train_data )>>> X_trainarray ( [ [ 2 2 . , 1 . , 0 . , . . . , 0 . , 0 . , 1 . ] ,

[ 3 8 . , 1 . , 0 . , . . . , 1 . , 0 . , 0 . ] ,

10

[ 2 6 . , 0 . , 0 . , . . . , 0 . , 0 . , 1 . ] ,. . . ,[ 2 8 . , 1 . , 2 . , . . . , 0 . , 0 . , 1 . ] ,[ 2 6 . , 0 . , 0 . , . . . , 1 . , 0 . , 0 . ] ,[ 3 2 . , 0 . , 0 . , . . . , 0 . , 1 . , 0 . ] ] )

On peut alors joindre les attributs catégoriels et numériques.

from sk l ea rn . p i p e l i n e import FeatureUnionprep roc e s s_p ipe l i n e = FeatureUnion ( t r an s f o rme r_ l i s t =[

( "num_pipeline" , num_pipeline ) ,( " ca t_p ipe l ine " , ca t_p ipe l ine ) ,

] )

On va alors réaliser l’apprentissage.

>>> X_train = prep roce s s_p ipe l i n e . f i t_trans fo rm ( train_data )>>> X_trainarray ( [ [ 2 2 . , 1 . , 0 . , . . . , 0 . , 0 . , 1 . ] ,

[ 3 8 . , 1 . , 0 . , . . . , 1 . , 0 . , 0 . ] ,[ 2 6 . , 0 . , 0 . , . . . , 0 . , 0 . , 1 . ] ,. . . ,[ 2 8 . , 1 . , 2 . , . . . , 0 . , 0 . , 1 . ] ,[ 2 6 . , 0 . , 0 . , . . . , 1 . , 0 . , 0 . ] ,[ 3 2 . , 0 . , 0 . , . . . , 0 . , 1 . , 0 . ] ] )

>>> y_train = train_data [ " Survived " ]>>> sgd_cl f . f i t ( X_train , y_train )Out [ 2 6 3 ] :SGDClass i f i e r ( alpha =0.0001 , average=False , c lass_weight=None , e p s i l o n =0.1 ,

eta0 =0.0 , f i t_ i n t e r c e p t=True , l 1_rat i o =0.15 ,l ea rn ing_rate=’ optimal ’ , l o s s=’ hinge ’ , max_iter=5, n_iter=None ,n_jobs=1, pena l ty=’ l 2 ’ , power_t=0.5 , random_state=42, s h u f f l e=True ,t o l=None , verbose =0, warm_start=False )

>>> X_test = prep roc e s s_p ipe l i n e . trans form ( test_data )

>>> y_pred = sgd_cl f . p r ed i c t ( X_test )>>> sco r e s = cross_val_score ( sgd_clf , X_train , y_train , cv=10)>>> sco r e s . mean ( )

Que pensez-vous du résultat ?Quel score obtiendrait un classifieur retournant la classe majoritaire ?Qu’obtient-on en utilisant un algorithme de prédiction par plus proches voisins (k-ppv) ?

On peut les utiliser par les commandes :

>>> from sk l e a rn . ne ighbors import KNe ighbo r sC la s s i f i e r>>> knn_clf = KNe ighbo r sC la s s i f i e r ( n_jobs=−1, weights=’ d i s t ance ’ , n_neighbors=4)>>> knn_clf . f i t ( X_train , y_train )

11

5. Apprentissage par arbres de décision et par « random forests »

5.1 Apprentissage par arbres de décision

Nous allons maintenant essayer l’induction par arbres de décision.

>>> from sk l e a rn . da ta s e t s import l o ad_ i r i s>>> from sk l e a rn . t r e e import De c i s i o nT r e eC l a s s i f i e r

>>> i r i s = l o ad_ i r i s ( )>>> X = i r i s . data [ : , 2 : ] # pe t a l l e n g t h and width>>> y = i r i s . t a r g e t

>>> t r e e_c l f = De c i s i o nT r e eC l a s s i f i e r (max_depth=2, random_state=42)>>> t r e e_c l f . f i t (X, y )

out [ 2 ] D e c i s i o nT r e eC l a s s i f i e r ( c lass_weight=None , c r i t e r i o n=’ g i n i ’ , max_depth=2,max_features=None , max_leaf_nodes=None ,min_impurity_split=1e−07, min_samples_leaf=1,min_samples_split=2, min_weight_fract ion_leaf =0.0 ,p r e s o r t=False , random_state=42, s p l i t t e r=’ bes t ’ )

On ne garde ici que deux descripteurs sur les quatre décrivant les fleurs dans la base iris :petal length et petal width. Puis nous allons visualiser le résultat de l’apprentissage.

from sk l ea rn . t r e e import export_graphviz

export_graphviz (t r e e_c l f ,ou t_ f i l e=image_path ( " i r i s_ t r e e . dot" ) ,feature_names=i r i s . feature_names [ 2 : ] ,class_names=i r i s . target_names ,rounded=True ,f i l l e d=True

)

p l t . f i g u r e ( f i g s i z e =(8 , 4 ) )plot_decis ion_boundary ( t r e e_c l f , X, y )p l t . p l o t ( [ 2 . 4 5 , 2 . 4 5 ] , [ 0 , 3 ] , "k−" , l i n ew id th =2)p l t . p l o t ( [ 2 . 4 5 , 7 . 5 ] , [ 1 . 7 5 , 1 . 7 5 ] , "k−−" , l i n ew id th =2)p l t . p l o t ( [ 4 . 9 5 , 4 . 9 5 ] , [ 0 , 1 . 7 5 ] , "k : " , l i n ew id th =2)p l t . p l o t ( [ 4 . 8 5 , 4 . 8 5 ] , [ 1 . 7 5 , 3 ] , "k : " , l i n ew id th =2)p l t . t ex t ( 1 . 4 0 , 1 . 0 , "Depth=0" , f o n t s i z e =15)p l t . t ex t ( 3 . 2 , 1 . 80 , "Depth=1" , f o n t s i z e =13)p l t . t ex t ( 4 . 0 5 , 0 . 5 , " (Depth=2)" , f o n t s i z e =11)

save_f ig ( " dec i s ion_tree_dec i s ion_boundar ies_plot " )p l t . show ( )

Les commandes précédentes devraient produire une figure comme la figure 6.Les arbres de décision peuvent fournir des estimations de probabilité d’appartenance d’unexemple aux classes. Pour cela, lorsqu’un exemple est présenté, il est attribué à une feuille

12

Figure 6 – Régions délimitées par l’arbre de décisions appris sur la base iris à partir desattributs petal length et petal width.

de l’arbre en suivant les tests des nœuds de l’arbre. Dans la feuille atteinte, les probabilitésd’appartenance aux classes sont estimées par la fréquence de ces classes parmi les exemplesd’apprentissage appartenant à cette feuille.Ainsi, pour l’exemple dont la longueur des pétales est 5 cm et la largeur 1.5 cm, la feuille del’arbre correspondante a 54 exemples d’apprentissage, dont 0 de la classe iris-Setosa (0%),49 de la classe Iris-Versicolor (90,7%) et 5 de la classe Iris-Verginica (9,3%). La classeprédite pour cet exemple est naturellement Iris-Versicolor (classe 1).

>>> t r e e_c l f . predict_proba ( [ [ 5 , 1 . 5 ] ] )Out [ 5 ] :array ( [ [ 0 . , 0 .90740741 , 0 . 0 9 2 5 9259 ] ] )

>>> t r e e_c l f . p r ed i c t ( [ [ 5 , 1 . 5 ] ] )Out [ 6 ] :array ( [ 1 ] )

5.2 Apprentissage par « random forests »

Qu’obtient-on en utilisant un algorithme de forêt aléatoire (random forest) ?

On peut les utiliser par les commandes :

>>> from sk l e a rn . ensemble import RandomForestClass i f i e r

>>> f o r e s t_ c l f = RandomForestClass i f i e r ( random_state=42)>>> sco r e s = cross_val_score ( f o r e s t_c l f , X_train , y_train , cv=10)>>> sco r e s . mean ( )

13

6. TP sur les SVM

6.1 Classification linéaire par SVM

Nous allons d’abord utiliser les SVM sur la classification du fameux jeu de données iris. Surce jeu de données, nous allons utiliser les SVM linéaires (donc nous cherchons un perceptron àmarge maximale).Nous définissons un problème de prédiction à deux classes : les Iris-Virginica (classe 1) contretous les autres types d’iris (classe 0). Vous devez utiliser le code suivant :

import numpy as npfrom sk l ea rn import da ta s e t sfrom sk l ea rn . p i p e l i n e import P ip e l i n efrom sk l ea rn . p r ep ro c e s s i ng import StandardSca lerfrom sk l ea rn . svm import LinearSVC

i r i s = data s e t s . l o ad_ i r i s ( )X = i r i s [ "data" ] [ : , ( 2 , 3 ) ] # pe t a l l eng th , p e t a l widthy = ( i r i s [ " t a r g e t " ] == 2 ) . astype (np . f l o a t 6 4 ) # Ir i s−Virg in i ca

svm_clf = P ip e l i n e ( [( " s c a l e r " , StandardSca ler ( ) ) ,( " l inear_svc " , LinearSVC (C=1, l o s s="hinge " , random_state =42)) ,

] )

svm_clf . f i t (X, y )

Vous pouvez alors utiliser la fonction de décision apprise pour faire des prédictions. Par exemple :

>>> svm_clf . p r ed i c t ( [ [ 5 . 5 , 1 . 7 ] ] )array ( [ 1 . ] )

La classe 1 est prédite, c’est-à-dire que l’exemple appartient la classe des à Iris-Verginica.

Ici, c’est un SVM linéaire (LinearSVC) qui a été utilisé. On aurait pu également faire ap-pel à la classe des SVC par un appel du type :SVC(kernel="linear", C=1). Mais ces SVM,d’usage plus général, puisqu’ils peuvent aussi réaliser des fonctions de décision non linéaires,sont aussi beaucoup plus gourmands en temps calcul, surtout avec de gros jeux de données. Uneautre possibilité est d’utiliser des SGDClassifier, avec l’appel SGDClassifier(loss="hinge",alpha=1/(m*C)). Ces SVM sont optimisés par une descente de gradient stochastique. Ils neconvergent pas aussi vite que linearSVC, mais peuvent traiter de très gros jeux de données quine tiennent pas dans la mémoire centrale, ou bien des données arrivant en flux.

1. En vous inspirant de la section 3, faites une validation croisée à 3 plis et calculez laperformance moyenne. Calculez aussi la matrice de confusion.

2. Refaites la même chose en posant C=100 et C=0.1. Qu’observez-vous ?

14

6.2 Classification non linéaire par SVM

Pour tester l’apprentissage de SVM non linéaires, nous allons utiliser le jeu de données demilunes que nous allons créé avec la fonction make_moons (ici avec 100 points, mais vous pouvezchanger ce nombre). La figure 7 montre ces données en deux dimensions.

>>> from sk l e a rn . da ta s e t s import make_moons>>> X, y = make_moons( n_samples=100 , no i s e =0.15 , random_state=42)

Figure 7 – Les données du jeu de données demi-lunes.

Nous allons dans un premier temps utiliser une fonction noyau polynomiale de degré 3.Ajoutez les lignes suivantes dans votre fichier python :

from sk l ea rn . svm import SVC

poly_kernel_svm_clf = P ipe l i n e ( [( " s c a l e r " , StandardSca ler ( ) ) ,( " svm_clf" , SVC( ke rne l="poly " , degree=3, coe f 0 =1, C=5))

] )poly_kernel_svm_clf . f i t (X, y )

Le coefficient coef0 contrôle à quel point les termes de degré élevé influencent la fonction dedécision. Pour un SCM avec fonction noyau polynomiale de degré 10 et un coef0 donnant plusde poids aux termes de degré élevé, nous définirons :

poly100_kernel_svm_clf = P ip e l i n e ( [( " s c a l e r " , StandardSca ler ( ) ) ,( " svm_clf" , SVC( ke rne l="poly " , degree =10, coe f 0 =100 , C=5))

] )poly100_kernel_svm_clf . f i t (X, y )

Nous pouvons alors produire les figures montrant les fonctions de décision correspondantes.

import numpy as npimport matp lo t l i b . pyplot as p l t

from sk l ea rn . svm import SVC

15

Figure 8 – Les SVM avec noyau polynomial de degré 3 et de degré 10 sur le jeu de donnéesdemi-lunes.

from sk l ea rn import da ta s e t sfrom sk l ea rn . p r ep ro c e s s i ng import StandardSca ler

from sk l ea rn . da ta s e t s import make_moonsX, y = make_moons( n_samples=100 , no i s e =0.15 , random_state=42)

de f p l o t_pred i c t i on s ( c l f , axes ) :x0s = np . l i n s p a c e ( axes [ 0 ] , axes [ 1 ] , 100)x1s = np . l i n s p a c e ( axes [ 2 ] , axes [ 3 ] , 100)x0 , x1 = np . meshgrid ( x0s , x1s )X = np . c_ [ x0 . r av e l ( ) , x1 . r av e l ( ) ]y_pred = c l f . p r ed i c t (X) . reshape ( x0 . shape )y_decis ion = c l f . d ec i s i on_func t i on (X) . reshape ( x0 . shape )p l t . contour f ( x0 , x1 , y_pred , cmap=p l t . cm . brg , alpha =0.2)p l t . contour f ( x0 , x1 , y_decis ion , cmap=p l t . cm . brg , alpha =0.1)

poly_kernel_svm_clf = P ipe l i n e ( [( " s c a l e r " , StandardSca ler ( ) ) ,( " svm_clf" , SVC( ke rne l="poly " , degree=3, coe f 0 =1, C=5))

] )poly_kernel_svm_clf . f i t (X, y )

poly100_kernel_svm_clf = P ip e l i n e ( [( " s c a l e r " , StandardSca ler ( ) ) ,( " svm_clf" , SVC( ke rne l="poly " , degree =10, coe f 0 =100 , C=5))

] )poly100_kernel_svm_clf . f i t (X, y )

p l t . f i g u r e ( f i g s i z e =(11 , 4 ) )

p l t . subp lot (121)p l o t_pred i c t i on s ( poly_kernel_svm_clf , [ −1.5 , 2 . 5 , −1, 1 . 5 ] )p lot_dataset (X, y , [ −1.5 , 2 . 5 , −1, 1 . 5 ] )p l t . t i t l e ( r "$d=3, r=1, C=5$" , f o n t s i z e =18)

p l t . subp lot (122)

16

p lo t_pred i c t i on s ( poly100_kernel_svm_clf , [ −1.5 , 2 . 5 , −1, 1 . 5 ] )p lot_dataset (X, y , [ −1.5 , 2 . 5 , −1, 1 . 5 ] )p l t . t i t l e ( r "$d=10, r =100 , C=5$" , f o n t s i z e =18)

save_f ig ( "moons_kernelized_polynomial_svc_plot " )p l t . show ( )

1. En vous inspirant de la section 3, faites une validation croisée à 5 plis et calculez laperformance moyenne pour le SVM utilisant un noyau polynomial de degré 3. Calculezaussi la matrice de confusion.

2. Refaites la même chose avec un SVM utilisant un noyau polynomial de degré 10.Qu’observez-vous ?

Nous allons maintenant utiliser des fonctions noyaux gaussiens.

rbf_kernel_svm_clf = P ip e l i n e ( [( " s c a l e r " , StandardSca ler ( ) ) ,( " svm_clf" , SVC( ke rne l=" rb f " , gamma=5, C=0.001))

] )rbf_kernel_svm_clf . f i t (X, y )

Faites à nouveau des expériences en utilisant le jeu de données demi-lunes et en faisant varierle paramètres gamma.

17

7. Sujet du Devoir à la Maison (pour le 29 juin 2018)

Le projet portera sur une étude des données des chiffres de la base MNIST et des données de labase Titanic.

7.1 Augmentation des données MNIST par mini-translations spatiales

Il est souvent intéressant de compléter l’échantillon d’apprentissage par des donnés « bruitées »,c’est-à-dire légèrement modifiées. Cela permet à la fois d’augmenter le nombre de données, maisaussi de rendre le classifieur plus robuste avec de meilleures performances de prédiction.Lorsque l’on connaît le type de transformations auxquelles on veut rendre le classifieur insensible,par exemple des translations ou des rotations des images, il est recommandé de « bruiter »les données en utilisant des transformations similaires. C’est ce que nous allons faire ici ensoumettant les images de chiffres à de petites translations.Nous utilisons la fonction shift() du module skips.ndimage.interpolation. Ainsi, l’appelshift(image, [2, 1], cval=0) translate l’image de 2 pixels vers le bas et d’un pixel vers ladroite.Vous pourrez utiliser la fonction shift_image dans le programme Classification_0.py dis-ponible sur le site du cours.

>>> shifted_image_down = shi ft_image ( image , 0 , 5)>>> plo t_d ig i t ( shifted_image_down )

donnerait quelque chose comme la figure 9.

Figure 9 – Un « huit », centré, translaté vers le bas de 5 pixels, et vers la gauche de 5 pixels.

On va augmenter la base de données MNIST avec ses images translatées de 1 pixel dans chacunedes 4 directions : bas, haut, droite et gauche :

>>> X_train_augmented = [ image f o r image in X_train ]>>> y_train_augmented = [ l a b e l f o r l a b e l in y_train ]

f o r dx , dy in ( ( 1 , 0 ) , (−1 , 0 ) , (0 , 1 ) , (0 , −1)):f o r image , l a b e l in z ip ( X_train , y_train ) :

X_train_augmented . append ( shi f t_image ( image , dx , dy ) )y_train_augmented . append ( l a b e l )

>>> X_train_augmented = np . array (X_train_augmented )>>> y_train_augmented = np . array ( y_train_augmented )

18

>>> shu f f l e_ idx = np . random . permutation ( l en (X_train_augmented ) )>>> X_train_augmented = X_train_augmented [ shu f f l e_ idx ]>>> y_train_augmented = y_train_augmented [ shu f f l e_ idx ]

On peut alors recommencer les expériences d’apprentissage de reconnaissance du chiffre ‘5’. Pourcela, vous construirez des ensembles d’entraînement et de test et vous évaluerez les performancesen prédiction par validation croisée.

Vous étudierez les classifieurs suivants :1. Un classifieur linéaire binaire (SGDClassifier)2. Un classifieur k-plus proches voisins (KNeighborsClassifier)3. Un classifieur par arbre de décision (DecisionTreeClassifier)4. Un classifieur par forêt aléatoire « random forest » (RandomForestClassifier)

Pour chacun d’entre eux, vous examinerez si l’utilisation de la base de données « augmentée »améliore les performances par rapport à l’utilisation de la base MNIST initiale.Vous comparerez les performances des 4 types de classifieurs d’une part sur les données MNIST(initiale et augmentée) et, d’autre part, sur les données Titanic. Vous fournirez un tableauavec en ligne les quatre types de classifieurs et sur deux colonnes le taux d’erreur moyen surla base MNIST originale et sur la base MNIST augmentée.

7.2 Étude sur les données Titanic

Vous utiliserez la base de données Titanic en ne prenant pas en compte les attributs « age »,« cabin » et « embarked » qui ont trop de valeurs manquantes. Pour l’attribut « age », vousferez comment dans la section 4 en remplaçant les valeurs manquantes par la valeur moyennedes valeurs connues sur cet attribut.

1. Apprenez des arbres de décision en faisant varier la profondeur maximale (max_depth)de 1 à 5

2. Pour chacun des arbres obtenus vous donnerez la performance en test (par validationcroisée)

3. Finalement, vous testerez un classifieur de type forêt aléatoire (RandomForestClassifier)et vous regarderez si la performance est meilleure qu’avec des arbres de décision (vousferez varier la profondeur max des arbres et vous retiendrez la meilleure performance).

On peut invoquer un classifieur par forêt aléatoire par les commandes :

>>> from sk l e a rn . ensemble import RandomForestClass i f i e r

>>> rnd_cl f = RandomForestClass i f i e r ( n_estimators =500 , max_depth=3,n_jobs=−1, random_state=42)>>> rnd_cl f . f i t ( X_train , y_train )

>>> y_pred_rf = rnd_cl f . p r ed i c t ( X_test )

19

Ici, 500 arbres sont appris, chacun pouvant avoir une profondeur maximale de 3.

Le rapport que vous rendrez rapportera les expériences réalisées, les performances obtenues etune analyse sur ces résultats.

20