Arbre de décision – Gini

 
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.
[table id=5 /] 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.

 
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 :

 
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.