Les arbres de décision apprennent leurs règles en décidant quels attributs mettre à la racine de l’arbre puis de chacun des noeuds. La sélection d’attributs se fait le plus souvent en calculant soit l’indice Gini soit l’entropie.

Pour notre exemple, nous nous inspirons de l’article how decision tree algorithm works.

ABCDE
4.83.41.90.21
531.60.21
53.41.60.41
5.23.51.50.21
5.23.41.40.21
4.73.21.60.21
4.83.11.60.21
5.43.41.50.41
73.24.71.40
6.43.24.51.50
6.93.14.91.50
5.52.341.30
6.52.84.61.50
5.72.84.51.30
6.33.34.71.60
4.92.43.310

Dans notre exemple, nous avons des données continues qu’il faut transformer en catégories. la dernière colonne est la variable dépendante.

Pour catégoriser les données, dans un premier temps on le fait de manière arbitraire.

A B C D
>= 5 >= 3.0 >=4.2 >= 1.4
< 5 < 3.0 < 4.2 < 1.4

 

Pour chacune des variables, calculons Gini.

Pour la variable A :

Il y a 12 éléments de A pour lesquels la valeur est >=5. 5 ont une classe positive, 7 une classe négative.

gini(5,7) = 1 – ((5/12)^2 + (7/12)^2) = 0,486

Il y a 4 éléments de A dont la valeur est <5. 5 qui ont une classe positive, 1 une classe négative.

gini(3,1) = 1 – ((3/4)^2 + (1/4)^2) = 0,375

gini(Target, A) = (12/16)*0,486 + (4/16)*0,375 = 0,458

Des calculs similaires sont effectués pour les variables B (0,333), C(0,2) et D (0,273).

En résumé, on a :

VRAI FAUX VRAI FAUX
A >=5.0 5 7 B >=3.0 8 4
<5 3 1 <3 0 4
Gini 0,458 Gini 0,333
VRAI FAUX VRAI FAUX
C >=4.2 0 6 D >=1.4 0 5
<4.2 8 2 <1,4 8 3
Gini 0,200 Gini 0,273

 

Ce qui nous donne cet arbre de décision :

Est-ce satisfaisant ?

Voyons-voir ce que donnerait le code :

On utilise skearn et pandas.

Après les imports, on lit les donnés dans un DataFrame. On sépare les variables indépendantes de la variable dépendante et on applique le classifier.

from sklearn.tree import DecisionTreeClassifier
import pandas as pd
df = pd.DataFrame([
[4.8,3.4,1.9,0.2,1],
[5,3,1.6,0.2,1],
[5,3.4,1.6,0.4,1],
[5.2,3.5,1.5,0.2,1],
[5.2,3.4,1.4,0.2,1],
[4.7,3.2,1.6,0.2,1],
[4.8,3.1,1.6,0.2,1],
[5.4,3.4,1.5,0.4,1],
[7,3.2,4.7,1.4,0],
[6.4,3.2,4.5,1.5,0],
[6.9,3.1,4.9,1.5,0],
[5.5,2.3,4,1.3,0],
[6.5,2.8,4.6,1.5,0],
[5.7,2.8,4.5,1.3,0],
[6.3,3.3,4.7,1.6,0],
[4.9,2.4,3.3,1,0]
], columns=list('ABCDE'))
y = df['E']
X = df.iloc[:,0:4]
tree_clf = DecisionTreeClassifier(max_depth=4, random_state=42)
tree_clf.fit(X, y)

Ensuite on affiche l’arbre :

from sklearn import tree
tree.export_graphviz(tree_clf,out_file='tree.dot') 

import pydot
from IPython.display import display, Image

(graph,) = pydot.graph_from_dot_file("tree.dot")
graph.write_png('tree.png')
display(Image(filename='tree.png'))

Que voit-on :

Comme on peut le voir, on peut avoir un arbre très simple. Pourquoi ? Parce qu’il suffit de choisir la colonne C avec un seuil à (ou autour) de 2,6 !

Ces données sont trop simplistes pour produire un arbre complexe. Modifions un petit peu les données.

En remplaçant la 1ère ligne par :

[4.8,3.4,3.9,1.2,1] au lieu de [4.8,3.4,1.9,0.2,1].

L’arbre de décision calculé par DecisionTreeClassifier devient :

On comprend que le calcul de l’indice Gini (ou autre) n’est pas suffisant. Il faut trouver les bons seuils.

 

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *