Transcript TP 2 – M1 Info – Arbres de décisions 1 Apprendre un arbre de

TP 2 – M1 Info – Arbres de d´ecisions
Le logiciel scikit-learn propose l’implantation de plusieurs algorithmes d’apprentissage d’arbres
de d´ecision. L’objectif de ce TP est triple :
— D´ecouvrir des arbres de d´ecision et leurs performances selon la nature des ´echantillons,
— D´ecouvrir le sur-apprentissage, ses liens avec complexit´e de l’espace d’hypoth`eses,
— Se familiariser avec l’entropie de Shannon.
1
Apprendre un arbre de d´
ecision
Le package sklearn.tree propose des algorithmes d’apprentissage fond´es sur les arbres de d´ecision
(classification, r´egression), mais aussi la possibilit´e de visualiser les arbres obtenus. Chaque algorithme d’apprentissage est param´etrable.
Dans cette partie, l’objectif est de comparer, pour deux ´echantillons de donn´ees, les performances
des arbres de d´ecision et celles du classifieur na¨ıf de Bayes. On utilisera l’algorithme DecisionTreeClassifier.
Pour ce faire :
1. Produire un programme Python qui charge le jeu de donn´ees Iris, et qui estime, par validation crois´ee, les erreurs en g´en´eralisation du classifieur na¨ıf de Bayes et d’un arbre de d´ecision
avec le param´etrage par d´efaut. Quelles performances obtenez-vous ?
2. Est-ce que les performances de l’arbre de d´ecision produit avec le crit`ere Gini sont meilleures
– ´egales – ou inf´erieures, aux performances obtenues avec le crit`ere Entropie ?
3. Quid des performances de ces deux algorithmes avec le jeu le donn´ees digits ?
2
A la d´
ecouverte de l’influence des param`
etres
La fonction DecisionTreeClassifier de scikit-learn offre de nombreux param`etres.
L’algorithme impl´ement´e actuellement ne r´ealise pas d’´elagage, et par d´efaut, la construction de
l’arbre est arrˆet´ee lorsqu’un arbre parfait a ´et´e obtenu (ou lorsqu’il n’y a plus de progression de
l’erreur d’apprentissage).
Nous allons voir que ces param`etres influencent la complexit´e de l’arbre, et sur ses performances.
1. Expliquer les param`etres criterion, max depth, min samples split et max features.
2. Sur le jeu de donn´ees digits, faire varier la profondeur maximum de 1 `a 40, pour obtenir une
dizaine d’arbres plus simples que l’arbre parfait (lorsque ce dernier existe), le 10`eme arbre
devant contenir un seul test. Pour chacun de ces arbres, indiquer :
— L’arbre lui-mˆeme (via la fonction sklearn.tree.export graphviz 1 ), son nombre de tests
et sa profondeur.
— L’erreur en apprentissage.
— Un estimation de l’erreur r´eelle par validation crois´ee.
Qu’observe-t-on – `
a valeur croissante de la profondeur maximum – quant `a l’´evolution des
erreur d’apprentissage et r´eelle ? Que constate-t’on lorsque l’erreur en apprentissage devient
nulle ?
3. De la mˆeme fa¸con, faire varier les trois autres param`etres. Dresser un tableau de r´esultats
(erreur app. et erreur r´eelle) en fonction de plusieurs valeurs de chaque param`etre de l’algorithme.
Peut-on indiquer quel est le meilleur arbre obtenu, et justifier ?
1. Cette fonction exporte un arbre sous format DOT. On peut alors convertir ce format en PNG via la commande
shell : dot -Tpng arbre15.dot -o arbre15.png
Universit´e Aix-Marseille – 2014-2015
TP 2 – M1 Info – Arbres de d´ecisions
4. On demande maintenant d’ajouter du bruit aux donn´ees, c’est-`a-dire que pour un certain
nombre d’exemples de l’´echantillon, leur classe est al´eatoirement modifi´ee. Ce bruit – appel´e
bruit de classification – gˆene ´evidemment l’obtention d’un bon apprenant.
Ce bruitage peut se r´ealiser grˆ
ace `a la fonction ci-dessous :
import random
from sklearn import datasets
# ds : un echantillon
# txb : le pourcentage d’exemples modifies
def add_noise(ds, txb=10):
nb_samples = len(ds.data)
nb_classes = len(ds.target_names)
for i in range(nb_samples*txb/100):
nc = random.randint(0, nb_classes-1)
ni = random.randint(0, nb_samples-1)
ds.target[ni]=nc
return ds
Reprendre les calculs et estimations des erreurs en apprentissage et r´eelles, pour plusieurs
profondeurs max de l’arbre, apr`es bruitage de 5, 10 et 20% de l’´echantillon. Que remarquet’on quand `
a l’´evolution de ces erreurs ? Pouvez-vous commenter ce ph´enom`ene ?
3
Stump, vous avez dit stump ?
Un stump est un arbre de d´ecision constitu´e d’un seul test `a la racine, avec s r´eponses possibles `a
ce test. A chaque r´eponse possible, une classe doit ˆetre attribu´ee.
Cr´eer une fonction Python qui, `
a partir d’un dataset – data et target – (multiclasses, attributs
continus, comme digits), calcule un stump en se fondant sur le crit`ere d’entropie de Shannon pour
calculer le gain en information : tester les performances de cet algorithme sur le jeu de donn´ees
digits.
Pr´
ecisions : nous supposons travailler sur des attributs continus, donc nous d´efinissons s le nombre
d’intervalles envisag´e pour l’attribut `
a choisir : 2 ≤ s ≤ 10. Dans un premier temps, la fonction
d’apprentissage consid`erera que s est fixe (par exemple 2) ; puis, si le temps le permet, on fera varier
s pour s´electionner le meilleur mod`ele de stump.
Universit´e Aix-Marseille – 2014-2015