Apprentissage Statistique avec Python.scikit-learn

[Pages:15]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)

6

Apprentissage Statistique avec Python.scikit-learn

for i, j, nom in zip(mca_df.fs_c()[:, 0], mca_df.fs_c()[:, 1], dc.columns): plt.text(i, j, nom)

show()

Comme pour l'ACP et au contraire de R (cf. FactoMineR), les librairies Python sont pauvres en fonctions graphiques directement adapt?es ? l'AFCM. Le graphique est construit ? partir des fonctions de MatPlotLib. Remarquer l'?vidente redondance entre la variable Prix et celle Classe. Il serait opportun d'en d?clarer une suppl?mentaire.

Il est alors facile de construire des classifications non supervis?es des modalit?s des variables ou des passagers ? partir de leurs composantes respectives quantitatives, ce qui revient ? consid?rer des distances dites du 2 entre ces objets. Tr?s utilis?es en marketing (segmentation de client?le), cette strat?gie n'a pas grand int?r?t sur ces donn?es.

3 Mod?lisation et apprentissage statistiques

Voici des exemples de mise en oeuvre de quelques unes des m?thodes de mod?lisation / apprentissage statistique les plus utilis?es.

Titanic

Il est n?cessaire de transformer les donn?es car scikit-learn ne reconna?t pas la classe DataFrame de pandas ce qui est bien dommage. Les variables qualitatives sont comme pr?c?demment remplac?es par les indicatrices de leurs modalit?s et les variables quantitatives conserv?es. Cela introduit une ?vidente redondance dans les donn?es mais les proc?dures de s?lection de mod?le feront le tri.

# Table de d?part df.head() # Table des indicatrices df1=pd.get_dummies(df_q[["Surv","Classe",

"Genre","Port","AgeQ","PrixQ"]]) # Une seule indicatrice par variable binaire df1=df1.drop(["Surv_Vnon","Genre_Gmas"],axis=1) # Variables quantitatives df2=df[["Age","Prix"]] # Concat?nation df_c=pd.concat([df1,df2],axis=1) # V?rification df_c.columns

3.1 Extraction des ?chantillons

Extraction des ?chantillons apprentissage et test.

Le travail pr?liminaire consiste ? s?parer les ?chantillons en une partie apprentissage et une autre de test pour estimer sans biais l'erreur de pr?vision. L'optimisation (biais-variance) de la complexit? des mod?les est r?alis?e en minimisant l'erreur estim?e par validation crois?e.

Caract?res

# variables explicatives T=df_c.drop(["Surv_Voui"],axis=1) # Variable ? mod?liser z=df_c["Surv_Voui"] # Extractions

T_train,T_test,z_train,z_test=train_test_split(T,z,

from sklearn.cross_validation

test_size=0.2,random_state=11)

import train_test_split

Attention : l'?chantillon test des donn?es "Titanic" est relativement petit,

X_train,X_test,y_train,y_test=train_test_split(X,y, l'estimation de l'erreur de pr?vision est donc sujette ? caution car proba-

test_size=0.25,random_state=11)

blement de grande variance. Il suffit de changer l'initialisation (param?tre

random_state) et r?-ex?cuter les scripts pour s'en assurer.

7

Apprentissage Statistique avec Python.scikit-learn

3.2 K plus proches voisins

Les images des caract?res sont cod?es par des variables quantitatives. Le probl?me de reconnaissance de forme ou de discrimination est adapt? ? l'algorithme des k-plus proches voisins. Le param?tre ? optimiser pour contr?ler la complexit? du mod?le est le nombre de voisin n_neighbors. Les options sont d?crites dans la documentation.

from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier(n_neighbors=10) digit_knn=knn.fit(X_train, y_train) # Estimation de l'erreur de pr?vision # sur l'?chantillon test 1-digit_knn.score(X_test,y_test)

Optimisation du param?tre de complexit? du mod?le par validation crois?e en cherchant l'erreur minimale sur une grille de valeurs du param?tre avec cv=5fold cross validation et n_jobs=1 pour une ex?cution en parall?le utilisant tous les processeurs sauf 1. Attention, comme la validation crois?e est al?atoire, deux ex?cutions successives ne donnent pas n?cessairement le m?me r?sultat.

from sklearn.grid_search import GridSearchCV # grille de valeurs param=[{"n_neighbors":list(range(1,15))}] knn= GridSearchCV(KNeighborsClassifier(),

param,cv=5,n_jobs=-1) digit_knn=knn.fit(X_train, y_train) # param?tre optimal digit_knn.best_params_["n_neighbors"]

Le mod?le est estim? avec la valeur "optimale" du param?tre.

knn = KNeighborsClassifier(n_neighbors= digit_knn.best_params_["n_neighbors"])

digit_knn=knn.fit(X_train, y_train) # Estimation de l'erreur de pr?vision 1-digit_knn.score(X_test,y_test) # Pr?vision

y_chap = digit_knn.predict(X_test) # matrice de confusion table=pd.crosstab(y_test,y_chap) print(table) matshow(table) title("Matrice de Confusion") colorbar() show()

3.3 R?gression logistique

La pr?vision de la survie, variable binaire des donn?es "Titanic", se pr?tent ? une r?gression logistique. Les versions p?nalis?es (Ridge, Lasso, elastic net, lars) du mod?le lin?aire g?n?ral sont les algorithmes les plus d?velopp?s dans scikit-learn au d?triment de ceux plus classique de s?lection de variables. Une version Lasso de la r?gression logistique est test?e afin d'introduire la s?lection automatique des variables.

Estimation et erreur de pr?vision du mod?le complet sur l'?chantillon test.

from sklearn.linear_model import LogisticRegression logit = LogisticRegression() titan_logit=logit.fit(T_train, z_train) # Erreur titan_logit.score(T_test, z_test) # Coefficients titan_logit.coef_

Comme pour le mod?le lin?aire, il faudrait construire les commandes d'aide ? l'interpr?tation des r?sultats.

P?nalisation et optimisation du param?tre par validation crois?e. Il existe une fonction sp?cifique mais son mode d'emploi est peu document? ; celle GridSearchCV, qui vient d'?tre utilis?e, lui est pr?f?r?e.

# grille de valeurs param=[{"C":[0.01,0.05,0.1,0.15,1,10]}] logit = GridSearchCV(LogisticRegression(penalty="l1"),

param,cv=5,n_jobs=-1) titan_logit=logit.fit(T_train, z_train)

8

Apprentissage Statistique avec Python.scikit-learn

# param?tre optimal titan_logit.best_params_["C"]

Estimation du mod?le "optimal".

logit = LogisticRegression(C=0.98,penalty="l1") titan_logit=logit.fit(T_train, z_train) # Erreur titan_logit.score(T_test, z_test) # Coefficients titan_logit.coef_

3.4 Arbre de d?cision

Impl?mentation

temps de calcul et pr?vision brute au d?triment d'une recherche d'interpr?tation. Dans certains exemples ?ventuellement pas trop compliqu?s, un arbre ?lagu? de fa?on optimal peut en effet pr?voir ? peine moins bien (diff?rence non significative) qu'une agr?gation de mod?les (for?t al?atoire ou boosting) et apporter un ?clairage nettement plus pertinent qu'un algorithme de type "bo?te noire".

Titanic

Estimation de l'arbre complet.

from sklearn.tree import DecisionTreeClassifier tree=DecisionTreeClassifier() digit_tree=tree.fit(T_train, z_train) # Estimation de l'erreur de pr?vision 1-digit_tree.score(T_test,z_test)

Les arbres binaires de d?cision (CART : classification and regression trees) s'appliquent ? tous types de variables. Les options de l'algorithme sont d?crites dans la documentation. La complexit? du mod?le est g?r?e par deux param?tres : max_depth, qui d?termine le nombre max de feuilles dans l'arbre, et le nombre minimales min_samples_split d'observations requises pour rechercher une dichotomie.

Attention : M?me s'il s'agit d'une impl?mentation proche de celle originale propos?e par Breiman et al. (1984)[2] il n'existe pas comme dans R (package rpart) un param?tre de p?nalisation de la d?viance du mod?le par sa complexit? (nombre de feuilles) afin de construire une s?quence d'arbres embo?t?s dans la perspective d'un ?lagage (pruning) optimal par validation crois?e. La fonction g?n?rique de k-fold cross validation GridSearchCV est utilis?e pour optimis?e le param?tre de profondeur mais avec beaucoup de pr?cision dans l'?lagage. Car ce dernier ?limine tout un niveau et pas les seules feuilles inutiles ? la qualit? de la pr?vision.

En revanche, l'impl?mentation anticipe sur celles des m?thodes d'agr?gation de mod?les en int?grant les param?tres (nombre de variables tir?es, importance...) qui leurs sont sp?cifiques. D'autre part, la repr?sentation graphique d'un arbre n'est pas incluse et n?cessite l'impl?mentation d'un autre logiciel libre : Graphviz.

Tout ceci souligne encore les objectifs de d?veloppement de cette librairie :

Optimisation du param?tre de complexit? du mod?le par validation crois?e en cherchant l'erreur minimale sur une grille de valeurs du param?tre avec cv=5fold cross validation et n_jobs=1 pour une ex?cution en parall?le utilisant tous les processeurs sauf 1. Attention, comme la validation crois?e est al?atoire et un arbre un mod?le instable, deux ex?cutions successives ne donnent pas n?cessairement le m?me r?sultat.

from sklearn.grid_search import GridSearchCV param=[{"max_depth":list(range(2,10))}] titan_tree= GridSearchCV(DecisionTreeClassifier(),

param,cv=5,n_jobs=-1) titan_opt=titan_tree.fit(T_train, z_train) # param?tre optimal titan_opt.best_params_

La valeur "optimale" du param?tre est encore trop importante. Une valeur plus faible est utilis?e.

tree=DecisionTreeClassifier(max_depth=3) titan_tree=tree.fit(T_train, z_train) # Estimation de l'erreur de pr?vision 1-titan_tree.score(T_test,z_test) # Estimation de l'erreur de pr?vision

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

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

Google Online Preview   Download