Université Sidi Mohamed Ben Abdallah de Fès

Département Mathématiques, Physique & Informatique Master SIM

Faculté Polydisciplinaire de Taza Machine & Deep learning

TP 3: Implémentation des arbres de décision

L'apprentissage par arbre de décision consiste à construire un arbre depuis un ensemble d'apprentissage
étiqueté. Chaque nœud interne décrit un test sur une variable d'apprentissage, chaque branche représente
un résultat du test, et chaque feuille contient la valeur de la variable de sortie.
Les algorithmes d'apprentissage par arbres de décision sont construits en divisant l'arbre du nœud racine
vers les feuilles en choisissant à chaque étape une variable d'entrée qui réalise le meilleur partage de
l'ensemble des observations sur le nœud courant. Pour choisir la variable de partage sur un nœud qu'on
appelle variable segmentation, l'algorithme teste les différentes variables d'entrée possibles et sélectionnent
celle qui maximise un critère donné.
Il existe un grand nombre de critères de ce type, les plus utilisés sont l’entropie de Shannon, l'indice de
diversité de Gini et leurs variantes.

1. Préparation des données

Nous allons d'abord importer le jeu de données iris à partir de sklearn.datasets. Ce jeu de données
relativement connu dans le monde du Machine Learning et il est exclusivement utilisé par des personnes
désirant s'initier dans ce domaine.

En 1936, Edgar Anderson a collecté des données sur 3 espèces d'iris: "iris setosa", "iris virginica" et "iris
versicolor"

Iris setosa Iris virginica Iris versicolor

Pour chaque iris étudié, Anderson a mesuré (en cm) :

 la largeur des sépales
 la longueur des sépales
 la largeur des pétales
 la longueur des pétales
Pour chaque iris mesuré, Anderson a aussi noté l'espèce ("Iris setosa", "Iris virginica" ou "Iris versicolor").
En résumé, vous trouverez dans le fichier iris:
 la longueur des pétales
 la largeur des pétales
 l'espèce de l'iris (au lieu d'utiliser les noms des espèces, on utilisera des chiffres : 0 pour "iris setosa",
1 pour "iris virginica" et 2 pour "iris versicolor")

Dictionnaire du jeu de données "iris"

1/6
 Université Sidi Mohamed Ben Abdallah de Fès
Département Mathématiques, Physique & Informatique Master SIM
Faculté Polydisciplinaire de Taza Machine & Deep learning

Par souci simplification, dans ce TP nous allons nous intéresser uniquement à la largeur et à la longueur des
pétales.

# Importation des packages

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Importation du jeu de données

from sklearn.datasets import load_iris
dataset=load_iris()

# Sélection du jeu de données d'entrée X et de sortie y

X = dataset.data[:,2:4]
y = dataset.target

Nous utilisons ensuite la bibliothèque matplotlib qui permet de tracer des graphiques très facilement.
"plt.scatter" permet de tracer des points. Le premier "plt.scatter" permet de tracer les points
correspondant à l'espèce "Iris setosa", ces points seront vert (color='g'), le deuxième "plt.scatter"
permet de tracer les points correspondant à l'espèce "Iris virginica", ces points seront rouge (color='r'),
enfin le troisième "plt.scatter" permet de tracer les points correspondant à l'espèce "Iris versicolor", ces
points seront bleu (color='b'). Nous aurons en abscisse la longueur du pétale et en ordonnée la largeur du
pétale.

# Visualisation des données

plt.scatter(X[:,0][y == 0], X[:,1][y == 0], color='g', label='setosa')
plt.scatter(X[:,0][y == 1], X[:,1][y == 1], color='r', label='virginica')
plt.scatter(X[:,0][y == 2], X[:,1][y == 2], color='b', label='versicolor')
plt.legend()

Vous devriez normalement obtenir ce graphique :

Nous obtenons des "nuages" de points, on remarque ces points sont regroupés par espèces d'iris sauf que
pour "Iris virginica" et "Iris versicolor", les points ont un peu tendance à se chevaucher.

Si on survol nos données, on remarque bien qu'il n'y a pas de données manquantes et il n'y a pas de
problème non plus le problème de variables catégoriques. Donc nous allons passez directement à la phase de
division des données en une partie d'entraînement et une partie de test. Puisqu'on a assez de données, nous
allons prendre 20% de ces données pour le test (test_size = 0.20) et 80% pour la phase d'entraînement.
# Subdivision des données en jeu d'entrainement et jeu de teste
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20,
random_state = 0)

2/6
 Université Sidi Mohamed Ben Abdallah de Fès
Département Mathématiques, Physique & Informatique Master SIM
Faculté Polydisciplinaire de Taza Machine & Deep learning

2. Construction de l'algorithme d'arbre de décision

Maintenant que nos données sont prêtes on va pouvoir appliquer l'algorithme d'arbre de décision sur notre
jeu d'entraînement.
La toute première étape à faire c'est d'importer l'objet qui va nous permettre de faire ce travail, c'est l'objet
DecisionTreeClassifier du package sklearn.tree qui va nous permettre de créer un modèle de
prédiction qu'on appelle classifier puis utiliser sa fonction fit() sur les données d'entrée X_train et des
données de sortie y_train pour l'entrainer.

# Creation du classifier
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier(criterion='gini', random_state=O)

# Entrainement du classifier
classifier.fit(X_train,y_train)

Le paramètre criterion de la méthode DecisionTreeClassifier définit le critère de segmentation des

nœuds de l'arbre. Elle permet l'utilisation de deux types de critère: L'entropie de Shannon 'entropy' ou
l'indice de diversité de Gini 'gini'.
D'autres paramètres peuvent être définit:
 max_depth pour limiter la profondeur de l’arbre (par défaut, pas de limites),
 min_samples split pour définir le nombre minimal d’exemples nécessaires pour développer un
nœud interne (2 par défaut)
 max_leaf_nodes pour définir le nombre maximal de feuilles de l’arbre.
Exemple:
Pour construire un arbre d'une profondeur maximal 3 et avec 5 feuilles au maximum, on écrit:
tree.DecisionTreeClassifier(criterion=’entropy’,max_depth=3,max_leaf_nodes=5)

3. Visualisation de l'arbre de décision

Une fois l’apprentissage terminé, nous pouvons visualiser l’arbre avec matplotlib en passant par la
méthode plot_tree():

# Visualisation de l'arbre de décision

# Importation de la bibliothèque tree nécessaire
from sklearn import tree

# Extrait du nom des données d'entrée

X_names = np.array(dataset.feature_names)[2:4]

# Visualisation
tree.plot_tree(classifier, feature_names= X_names)

On peut aussi utiliser l’outil graphviz avec matplotlib :

# Visualisation de l'arbre de décision

# Importation des bibliothèques nécessaires
from IPython.display import Image
import pydotplus

# Visualisation de l'arbre de décision

data = tree.export_graphviz(classifier,feature_names= X_names)
graph = pydotplus.graph_from_dot_data(data)
Image(graph.create_png())

3/6
 Université Sidi Mohamed Ben Abdallah de Fès
Département Mathématiques, Physique & Informatique Master SIM
Faculté Polydisciplinaire de Taza Machine & Deep learning

4. Evaluation de l'arbre de décision

Une fois que notre classifier est entrainée, on peut tester sa performance en l'exécutant sur les données de
test. En fait, nous allons donner à notre classifier les données d'entrée de test X_test, et on va voir est ce
qu'il est capable de bien prédire les sorties correspondantes qu'on va appeler y_pred. Pour faire ce travail
nous allons utiliser la fonction predict() du classifier.
# Prédiction des résultats de test
y_pred = classifier.predict(X_test)

Pour évaluer la performance de notre classifier d'une manière automatique, nous allons créer ce la matrice de
confusion qui permet de créer un résumé des résultats de prédictions correctes et incorrectes réparties par
classe. Les résultats sont ainsi comparés avec les valeurs réelles ce qui permet de savoir quel est le taux
d'erreur commit par le classifier.
# Création de la matrice de confusion
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

Matrice de confusion

4/6
 Université Sidi Mohamed Ben Abdallah de Fès
Département Mathématiques, Physique & Informatique Master SIM
Faculté Polydisciplinaire de Taza Machine & Deep learning

D'après la matrice de confusion, on voit bien que notre classifier est très performant, il n'arrive pas à bien
classer juste une seule observation parmi 30.

A réaliser: Extraire toutes les règles de prise de décision à partir du graphe de l'arbre précédemment obtenu?

5. Prédictions pour de nouvelles entrées

Imaginez maintenant qu'au cours d'une promenade vous trouviez un iris, n'étant pas un spécialiste, il ne vous
est pas vraiment possible de déterminer l'espèce. En revanche, vous êtes capables de mesurer la longueur et
la largeur des pétales de cet iris. Partons du principe qu'un pétale fasse 2cm de long et 0,5cm de large. Pour
placer cette nouvelle donnée sur notre graphique, il nous suffit d'ajouter la ligne "plt.scatter(2.0, 0.5,
color='k')", le nouveau point va apparaitre en noir (color='k') :

La classe de cette nouvelle fleur est simple à trouver à partir des règles de décision établies de l'arbre
obtenue. En effet, puisque la longueur de son pétale est inférieure à 2,5 alors il s'agit d'un iris setosa.

Il est possible de rencontrer des cas plus difficiles, par exemple: largeur du pétale=0,75cm ; longueur du
pétale=2,5cm :

Dans ce genre de cas, il peut être intéressant d'utiliser l'algorithme de prédiction:

# Information sur le nouvel iris
Longueur = 2.5
Largeur = 0.75

# Prédiction de sa classe
Prediction = classifier.predict([[longueur,largeur]])

Le résultat de prédiction montre que cette nouvelle fleur est un iris virginica.

5/6
 Université Sidi Mohamed Ben Abdallah de Fès
Département Mathématiques, Physique & Informatique Master SIM
Faculté Polydisciplinaire de Taza Machine & Deep learning

6. Réalisation

Les arbres de décision peuvent aussi être utilisés pour des problèmes de régression. Dans cette réalisation,
étudiez la base de données vinegar_quality.csv: Il s’agit de prédire la qualité d’un vinaigre en fonction de ses
différentes caractéristiques chimiques.

La dernière colonne correspond à la qualité du vinaigre qui est représentée par une valeur entière. Comme
précédemment, récupérerz la base, analysez les données et effectuez un apprentissage avec un arbre de
décision.

Faites varier l'algorithme DecisionTreeRegressor()avec différentes valeurs de max_depth et

max_leaf_nodes et choisir celui qui donne l'erreur quadratique moyenne minimale.

Indication:
Pour évaluer la performance de votre algorithme d'apprentissage, utilisez la méthode de calcul de l'erreur
quadratique mean_squared_erreur()de la bibliothèque sklearn.metrics:

from sklearn.metrics import mean_squared_error

7. Références

 Rokach, Lior, Maimon, Data mining with decision trees: theory and applications, 2nd Ed, World Scientific
Pub Co Inc., 2015.
 Hastie, Tibshirani, Friedman, The elements of statistical learning: data mining, inference, and
prediction. New York: Springer Verlag, 2006.
 Cornuejols, A., Miclet, L., Apprentissage Artificiel, Concepts et Algorithmes, Eyrolles, 2010.

6/6