Apprentissage Statistique avec Python.scikit-learn

1

Apprentissage Statistique avec Python.scikit-learn

Apprentissage Statistique avec Python.scikit-learn

R?sum?

Apr?s la pr?paration des donn?es, cette vignette introduit l'utilisation de la librairie scikit-learn pour la mod?lisation et l'apprentissage. Pourquoi utiliser scikit-learn ? Ou non ? Liste des fonctionnalit?s, quelques exemples de mise en oeuvre : exploration (ACP, AFCM, k-means), mod?lisation (r?gression logistique, k-plus proches voisins, arbres de d?cision, for?ts al?atoires. Optimisation des param?tres (complexit?) des mod?les par validation crois?e.

? Python pour Calcul Scientifique ? Trafic de Donn?es avec Python.Pandas ? Apprentissage Statistique avec Python.Scikit-learn ? Programmation ?l?mentaire en Python ? Sciences des donn?es avec Spark-MLlib

1 Introduction

1.1 Scikit-learn vs. R

L'objectif de ce tutoriel est d'introduire la librairie scikit-learn de Python dont les fonctionnalit?s sont pour l'essentiel un sous-ensemble de celles propos?es par les librairies de R. Se pose alors la question : quand utiliser scikit-learn de Python plut?t que par exemple caret de R plus complet et plus simple d'emploi ?

Le choix repose sur les points suivants : ? Attention cette librairie manipule des objets de classe array de numpy

charg?s en m?moire et donc de taille limit?e par la RAM de l'ordinateur ; de fa?on analogue R charge en RAM des objets de type data.frame. ? Attention toujours, scikit-learn (0.16) ne reconna?t pas (ou pas encore ?) la classe DataFrame de pandas ; scikit-learn utilise la classe array de numpy. C'est un probl?me pour la gestion de va-

riables qualitatives complexes. Une variable binaire est simplement remplac?e par un codage (0, 1) mais, en pr?sence de plusieurs modalit?s, traiter celles-ci comme des entiers n'a pas de sens statistique et remplacer une variable qualitative par l'ensemble des indicatrices (dummy variables(0, 1)) de ses modalit?s complique les strat?gies de s?lection de mod?le et rend inexploitable l'interpr?tation statistique. ? Les impl?mentations en Python de certains algorithmes dans scikit-learn sont aussi efficaces (i.e. k-means), voire beaucoup plus efficaces (i.e. for?ts al?atoires) pour des donn?es volumineuses. ? R offre beaucoup plus de possibilit?s pour une exploration, des recherches et comparaisons de mod?les, des interpr?tations mais les capacit?s de parall?lisation de Python sont plus performantes. Plus pr?cis?ment, l'introduction de nouvelles librairies n'est pas ou peu contraintes dans R comme en Python alors que celle de nouvelles m?thodes dans scikit-learn est sous contr?le d'un petit groupe qui v?rifie la pertinence des m?thodes, seules celles reconnues sont accept?es, et l'efficacit? du code. En cons?quences : ? Pr?f?rer R et ses libraires si la pr?sentation (graphiques) des r?sultats et leur interpr?tation est prioritaire, si l'utilisation et / ou la comparaison de beaucoup de m?thodes est recherch?e. ? Pr?f?rer Python et scikit-learn pour mettre au point une cha?ne de traitements (pipe line) op?rationnelle de l'extraction ? une analyse privil?giant la pr?vision brute ? l'interpr?tation et pour des donn?es quantitatives ou rendues quantitatives ("vectorisation" de corpus de textes). En revanche, si les donn?es sont trop volumineuses pour la taille du disque et distribu?es sur les noeuds d'un cluster sous Hadoop, consulter l'?tape suivante pour l'utilisation de MLlib de Spark/Hadoop.

1.2 Fonctions de scikit-learn

La communaut? qui d?veloppe cette librairie est tr?s active, elle ?volue rapidement. Ne pas h?siter ? consulter la documentation pour des compl?ments. Voici une s?lection de ses principales fonctionnalit?s.

? Transformations (standardisation, discr?tisation binaire, regroupement de modalit?s, imputations rudimentaires de donn?es manquantes) , "vectorisation" de corpus de textes (encodage, catalogue, Tf-idf), images.

? Exploration : ACP, classification non supervis?e (m?langes gaussiens,

2

Apprentissage Statistique avec Python.scikit-learn

propagation d'affinit?, ascendante hi?rarchique, SOM,...) ? Mod?le lin?aire g?n?ral avec p?nalisation (ridge, lasso, elastic net...), ana-

lyse discriminante lin?aire et quadratique, k plus proches voisins, processus gaussiens, classifieur bay?sien na?f, arbres de r?gression et classification (CART), agr?gation de mod?les (bagging, random forest, adaboost, gradient tree boosting), SVM (classification, r?gression, d?tection d'atypiques...). ? Algorithmes de validation crois?e (loo, k-fold, VC stratifi?e...) et s?lection de mod?les, optimisation sur une grille de param?tres, s?paration al?atoire apprentissage et test, encha?nement (pipe line) de traitements, courbe ROC. En r?sum?, cette librairie est focalis?e sur les aspects "machine" de l'apprentissage de donn?es quantitatives (s?ries, signaux, images) volumineuses tandis que R int?gre l'analyse de variables qualitatives complexes et l'interpr?tation statistique fine des r?sultats au d?triment parfois de l'efficacit? des calculs.

Les diff?rences d'usage entre R et Pyhton.scikitlearn r?sument finalement les nuances qui peuvent ?tre mises en ?vidences entre apprentissage Statistique et apprentissage Machine.

1.3 Objectif

L'objectif est d'illustrer la mise en oeuvre de quelques fonctionnalit?s 1 de la librairie scikit-learn.

Deux jeux de donn?es ?l?mentaires sont utilis?s. Celui pr?c?dent g?r? avec pandas et concernant le naufrage du Titanic m?lange des variables explicatives qualitatives et quantitatives dans un objet de la classe DataFrame. Pour ?tre utilis? dans scikit-learn les donn?es doivent ?tre transform?es en un objet de classe Array de numpy en rempla?ant les variables qualitatives par les indicatrices de leurs modalit?s. L'autre ensemble de donn?es est enti?rement quantitatif. C'est un probl?me classique de reconnaissance de caract?res qui est inclus dans la librairie scikit-learn, de m?me que les trop fameux iris de Fisher.

Ces donn?es sont explor?es par analyse en composantes principales (caract?res) ou analyse multiple des correspondances (titanic), classifi?es puis mod?lis?es par r?gression logistique (titanic), k- plus proches voisins (caract?res),

arbres de discrimination, et for?ts al?atoires. Les param?tres de complexit? des mod?les sont optimis?s par minimisation de l'erreur de pr?vision estim?e par validation crois?e.

D'autres fonctionnalit?s sont laiss?es momentan?ment de c?t? ; cela concerne les possibilit?s d'encha?nement (pipeline) de m?thodes et d'automatisation. Il s'agit, par exemple, de r?p?ter automatiquement la s?paration al?atoire des ?chantillons apprentissage et test pour estimer les distributions des erreurs, comme c'est relativement facile ? mettre en oeuvre en R avec la librairie caret 2. Ces fonctionnalit?s seront d?velopp?es en Python avec les sc?narios ? venir sur des donn?es plus complexes et plus volumineuses.

2 Exploration multidimensionnelle

2.1 Les donn?es

Les donn?es "Caract?res"

Il s'agit d'explorer celles de reconnaissance de caract?res dont les proc?d?s d'obtention et pr?traitements sont d?crits sur le site de l'UCI (Lichman, 2013)[3]. Les chiffres ont ?t? saisies sur des tablettes ? l'int?rieur de cadres de r?solution 500 ? 500. Des proc?dures de normalisation, r?-?chantillonnage spatial puis de lissage ont ?t? appliqu?es. Chaque caract?re appara?t finalement discr?tis? sous la forme d'une matrice 8 ? 8 de pixels ? 16 niveaux de gris et identifi? par un label. Les donn?es sont archiv?es sous la forme d'une matrice ou tableau ? trois indices. Elles sont ?galement archiv?es apr?s vectorisation des images sous la forme d'une matrice ? p = 64 colonnes.

Ouvrir la fen?tre d'un calepin ipython dans un navigateur.

# Importations import matplotlib.pyplot as plt from sklearn import datasets %matplotlib inline # les donn?es digits = datasets.load_digits() # Contenu et mode d'obtention print(digits)

1. Consulter la documentation et ses nombreux exemples pour plus de d?tails.

2. Consulter les sc?narios de wikistat.fr.

3

Apprentissage Statistique avec Python.scikit-learn

# Dimensions digits.images.shape # Sous forme d'un cube d'images 1797 x 8x8 print(digits.images) # Sous forme d'une matrice 1797 x 64 print(digits.data) # Label r?el de chaque caract?re print(digits.target)

Voici un aper?u des images ? discriminer :

images_and_labels = list(zip(digits.images, digits.target))

for index, (image, label) in enumerate(images_and_labels[:8]): plt.subplot(2, 4, index + 1) plt.axis('off') plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest') plt.title('Training: %i' % label)

Titanic

Les donn?es sur le naufrage du Titanic sont d?crites dans le sc?nario consacr? ? pandas. Reconstruire la table de donn?es en lisant le fichier .csv disponible dans ce r?pertoire ou charger l'archive au format HDF5.

# Lire les donn?es d'apprentissage import pandas as pd df=pd.read_csv("titanic-train.csv",skiprows=1,

header=None,usecols=[1,2,4,5,9,11], names=["Surv","Classe","Genre","Age",

"Prix","Port"],dtype={"Surv":object, "Classe":object,"Genre":object,"Port":object}) df.head() # dimensions df.shape # Red?finir les types

df["Surv"]=pd.Categorical(df["Surv"],ordered=False) df["Classe"]=pd.Categorical(df["Classe"],

ordered=False) df["Genre"]=pd.Categorical(df["Genre"],

ordered=False) df["Port"]=pd.Categorical(df["Port"],ordered=False) df.dtypes

V?rifier que les donn?es contiennent des valeurs manquantes, faire des imputations ? la m?diane d'une valeur quantitative manquante ou la modalit? la plus fr?quente d'une valeur qualitative absente.

df.count() # imputation des valeurs manquantes df["Age"]=df["Age"].fillna(df["Age"].median()) df.Port=df["Port"].fillna("S")

Continuer en transformant les variables.

# Discr?tiser les variables quantitatives df["AgeQ"]=pd.qcut(df_train.Age,3,labels=["Ag1",

"Ag2","Ag3"]) df["PrixQ"]=pd.qcut(df_train.Prix,3,labels=["Pr1",

"Pr2","Pr3"]) # red?finir les noms des modalit?s df["Surv"]=df["Surv"].cat.rename_categories(

["Vnon","Voui"]) df["Classe"]=df["Classe"].cat.rename_categories(

["Cl1","Cl2","Cl3"]) df["Genre"]=df["Genre"].cat.rename_categories(

["Gfem","Gmas"]) df["Port"]=df["Port"].cat.rename_categories(

["Pc","Pq","Ps"]) df.head()

2.2 Analyse en composantes principales

La fonction d'analyse en composantes principales (ACP) est surtout adapt?e ? l'analyse de signaux, de nombreuses options ne sont pas disponibles no-

4

Apprentissage Statistique avec Python.scikit-learn

tamment les graphiques usuels (biplot, cercle des corr?lations...). En revanche des r?sultats sont li?s ? la version probabiliste de l'ACP sous hypoth?se d'une distribution gaussienne multidimensionnelle des donn?es. Attention, l'ACP est ?videmment centr?e mais par r?duite. L'option n'est pas pr?vue et les variables doivent ?tre r?duites (fonction sklearn.preprocessing.scale) avant si c'est n?cessaire. L'attribut transform d?signe les composantes principales, sous-entendu : transformation par r?duction de la dimension ; n_components fixe le nombre de composantes retenues, par d?faut toutes ; l'attribut components_ contient les n_components vecteurs propres mais non normalis?s, c'est-?-dire de norme carr?e la valeur propre associ?e et donc ? utiliser pour repr?senter les variables.

from sklearn.decomposition import PCA X=digits.data y=digits.target target_name=[0,1,2,3,4,5,6,7,8,9] # d?finition de la commande pca = PCA() # Estimation, calcul des composantes principales C = pca.fit(X).transform(X) # D?croissance de la variance expliqu?e plot(pca.explained_variance_ratio_) show()

Diagramme bo?te des premi?res composantes principales.

[0,1,2,3,4,5,6,7,8,9], target_name): plt.scatter(C[y == i,0], C[y == i,1], c=c, label=target_name)

plt.legend() plt.title("ACP Digits") show()

Graphique en trois dimensions.

from mpl_toolkits.mplot3d import Axes3D fig = plt.figure(1, figsize=(8, 6)) ax = Axes3D(fig, elev=-150, azim=110) ax.scatter(C[:, 0], C[:, 1], C[:, 2], c=y,

cmap=plt.cm.Paired) ax.set_title("ACP: trois premieres composantes") ax.set_xlabel("Comp1") ax.w_xaxis.set_ticklabels([]) ax.set_ylabel("Comp2") ax.w_yaxis.set_ticklabels([]) ax.set_zlabel("Comp3") ax.w_zaxis.set_ticklabels([]) show()

D'autres versions d'analyse en composantes principales sont propos?es : kernel PCA, sparse PCA...

boxplot(C[:,0:20])

2.3 Classification non supervis?e

show()

Ex?cution de l'algorithme de classification non supervis?e (clustering) k-

Repr?sentation des caract?res dans le premier plan principal.

means dans un cas simple : le nombre des classes : param?tre n_clusters (8 par d?faut) est a priori connu. D'autres param?tres peuvent ?tre pr?cis?s

plt.scatter(C[:,0], C[:,1], c=y, label=target_name) ou laiss?s ? leur valeur par d?faut. Le nombre max_iter d'it?rations (300),

show()

le nombre n_init (10) d'ex?cutions parmi lesquelles la meilleure en terme

Le m?me graphique avec une l?gende mais moins de couleurs.

de minimisation de la variance intra-classe est retenue, le mode init d'initialisation qui peut ?tre k-means++ (par d?faut) pour en principe acc?l?rer

# attention aux indentations plt.figure()

la convergence, random parmi les donn?es, ou une matrice d?terminant les centres initiaux.

for c, i, target_name in zip("rgbcmykrgb",

L'option n_jobs permet d'ex?cuter les n_init en parall?le. Pour la va-

5

Apprentissage Statistique avec Python.scikit-learn

leur -2, tous les processeurs sauf un sont utilis?s. Les attributs en sortie contiennent les centres : cluster_centers_, les

num?ros de classe de chaque observation : labels_. De nombreux crit?res ? consulter dans la documentation sont propos?s pour

?valuer la qualit? d'une classification non-supervis?e. On se contente des options par d?faut dans cette illustration.

from sklearn.cluster import KMeans from sklearn.metrics import confusion_matrix est=KMeans(n_clusters=10) est.fit(X) classe=est.labels_ print(classe)

ax.w_zaxis.set_ticklabels([]) show()

2.4 Analyse multiple des correspondances

Les donn?es "Titanic" regroupent des variables qualitatives et quantitatives. Apr?s recodage en classes (discr?tisation) (cf. le sc?nario sur l'utilisation de pandas) des variables quantitatives, la table obtenue se pr?te ? une analyse factorielle multiple des correspondances. Cette m?thode n'est pas pr?sente dans les librairies courantes de python mais disponible sous la forme d'une fonction mca.py. Il est possible d'installer la librairie correspondante ou de simplement charger le seul module mca.py dans le r?pertoire courant. Remarque, il ne serait pas plus compliqu? de recalculer directement les composantes de l'AFCM ? partir de la SVD du tableau disjonctif complet.

Les vraies classes ?tant connues, il est facile de construire une matrice de Ce tableau est obtenu en rempla?ant chaque variables par les indicatrices,

confusion.

ou dummy variables, de ses modalit?s.

import pandas as pd table=pd.crosstab(df["Surv"],df["Classe"]) print(table) matshow(table) title("Matrice de Confusion") colorbar() show()

Il n'est pas plus difficile de repr?senter les classes dans les coordonn?es de l'ACP. C'est la variable classe qui d?finit les couleurs.

# Suppression des variables quantitatives # pour l'AFCM df_q=df.drop(["Age","Prix"],axis=1) df_q.head() # Indicatrices dc=pd.DataFrame(pd.get_dummies(df_q[["Surv",

"Classe","Genre","Port","AgeQ","PrixQ"]])) dc.head()

Calcul de l'AFCM et repr?sentations graphiques.

fig = plt.figure(1, figsize=(8, 6)) ax = Axes3D(fig, elev=-150, azim=110) ax.scatter(C[:, 0], C[:, 1], C[:, 2], c=classe,

cmap=plt.cm.Paired) ax.set_title("ACP: trois premieres composantes") ax.set_xlabel("Comp1") ax.w_xaxis.set_ticklabels([]) ax.set_ylabel("Comp2") ax.w_yaxis.set_ticklabels([]) ax.set_zlabel("Comp3")

import mca mca_df=mca(dc,benzecri=False) # Valeurs singuli?res print(mca_df.L) # Composantes principales des colonnes (modalit?s) print(mca_df.fs_c()) # Premier plan principal col=[1,1,2,2,2,3,3,5,5,5,6,6,6,7,7,7] plt.scatter(mca_df.fs_c()[:, 0],

mca_df.fs_c()[:, 1],c=col)

 ................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download