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

TP 2 – M1 Info – Arbres de décisions
Le logiciel scikit-learn propose l’implantation de plusieurs algorithmes d’apprentissage d’arbres
de décision. L’objectif de ce TP est triple :
— Découvrir des arbres de décision et leurs performances selon la nature des échantillons,
— Découvrir le sur-apprentissage, ses liens avec complexité de l’espace d’hypothèses,
— Se familiariser avec l’entropie de Shannon.
1
Apprendre un arbre de décision
Le package sklearn.tree propose des algorithmes d’apprentissage fondés sur les arbres de décision
(classification, régression), mais aussi la possibilité de visualiser les arbres obtenus. Chaque algorithme d’apprentissage est paramétrable.
Dans cette partie, l’objectif est de comparer, pour deux échantillons de données, les performances
des arbres de décision 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ées Iris, et qui estime, par validation croisée, les erreurs en généralisation du classifieur naı̈f de Bayes et d’un arbre de décision
avec le paramétrage par défaut. Quelles performances obtenez-vous ?
2. Est-ce que les performances de l’arbre de décision produit avec le critère Gini sont meilleures
– égales – ou inférieures, aux performances obtenues avec le critère Entropie ?
3. Quid des performances de ces deux algorithmes avec le jeu le données digits ?
2
A la découverte de l’influence des paramètres
La fonction DecisionTreeClassifier de scikit-learn offre de nombreux paramètres.
L’algorithme implémenté actuellement ne réalise pas d’élagage, et par défaut, la construction de
l’arbre est arrêtée lorsqu’un arbre parfait a été obtenu (ou lorsqu’il n’y a plus de progression de
l’erreur d’apprentissage).
Nous allons voir que ces paramètres influencent la complexité de l’arbre, et sur ses performances.
1. Expliquer les paramètres criterion, max depth, min samples split et max features.
2. Sur le jeu de données digits, faire varier la profondeur maximum de 1 à 40, pour obtenir une
dizaine d’arbres plus simples que l’arbre parfait (lorsque ce dernier existe), le 10ème arbre
devant contenir un seul test. Pour chacun de ces arbres, indiquer :
— L’arbre lui-même (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éelle par validation croisée.
Qu’observe-t-on – à valeur croissante de la profondeur maximum – quant à l’évolution des
erreur d’apprentissage et réelle ? Que constate-t’on lorsque l’erreur en apprentissage devient
nulle ?
3. De la même façon, faire varier les trois autres paramètres. Dresser un tableau de résultats
(erreur app. et erreur réelle) en fonction de plusieurs valeurs de chaque paramètre 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é Aix-Marseille – 2014-2015
TP 2 – M1 Info – Arbres de décisions
4. On demande maintenant d’ajouter du bruit aux données, c’est-à-dire que pour un certain
nombre d’exemples de l’échantillon, leur classe est aléatoirement modifiée. Ce bruit – appelé
bruit de classification – gêne évidemment l’obtention d’un bon apprenant.
Ce bruitage peut se réaliser grâce à 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éelles, pour plusieurs
profondeurs max de l’arbre, après bruitage de 5, 10 et 20% de l’échantillon. Que remarquet’on quand à l’évolution de ces erreurs ? Pouvez-vous commenter ce phénomène ?
3
Stump, vous avez dit stump ?
Un stump est un arbre de décision constitué d’un seul test à la racine, avec s réponses possibles à
ce test. A chaque réponse possible, une classe doit être attribuée.
Créer une fonction Python qui, à partir d’un dataset – data et target – (multiclasses, attributs
continus, comme digits), calcule un stump en se fondant sur le critère d’entropie de Shannon pour
calculer le gain en information : tester les performances de cet algorithme sur le jeu de données
digits.
Précisions : nous supposons travailler sur des attributs continus, donc nous définissons s le nombre
d’intervalles envisagé pour l’attribut à choisir : 2 ≤ s ≤ 10. Dans un premier temps, la fonction
d’apprentissage considèrera que s est fixe (par exemple 2) ; puis, si le temps le permet, on fera varier
s pour sélectionner le meilleur modèle de stump.
Université Aix-Marseille – 2014-2015