Les arbres de décision sont un modèle d'apprentissage automatique supervisé utilisé à la fois pour les tâches de classification et de régression (CART). Ils sont faciles à mettre en œuvre, à expliquer et font partie des outils d'apprentissage automatique les plus utilisés.

Les arbres sont des modèles non linéaires non paramétriques , ce qui signifie que leur fonction peut prendre autant de paramètres que nécessaire ( à la différence d'une régression linéaire fixée sur a = intercept, b = pente ) et générer une cartographie non linéaire de X à y .

Arbres de classification et de régression (CART)

Les arbres de décision peuvent être divisés en 2 catégories :

1. Arbres de régression : arbres de décision où la variable cible peut prendre des valeurs continues ( généralement des nombres ).
2. Arbres de classification : modèles d'arbres où la variable cible prend un ensemble discret de valeurs ( classes ).

Idée principale : Gain d'information (IG)

Un arbre de décision divisera chaque nœud parent en deux nœuds enfants en fonction de la caractéristique qui permettra d'atteindre le gain d'informations maximal à ce stade. Ce processus commencera au nœud racine (première division) et se poursuivra jusqu'à ce que tous les nœuds enfants soient purs, ou jusqu'à ce que le gain d'informations soit égal à 0 (à moins que nous ne définissions manuellement un paramètre « max_depth »).

Le gain d'informations mesure de combien l' entropie (une mesure de l' impureté ou du caractère aléatoire d'un ensemble de données) est réduite en divisant les données sur une caractéristique donnée et l'arbre développe ses branches en se divisant consécutivement sur les caractéristiques, du plus prédictif au moins .

Minimiser l'entropie équivaut à maximiser le gain d'information et c'est exactement ce que l'arbre vise à atteindre à chaque division.

Les deux principaux critères pour mesurer l'impureté d'un nœud I, dans un jeu de données avec n classes de probabilité P différentes, sont l' indice de Gini :

et entropie :

L'indice de Gini a tendance à être plus efficace sur le plan informatique, il est donc le plus souvent implémenté dans l'algorithme de décision trois. A tous ceux qui souhaitent en savoir plus, je recommande cette vidéo . Cela m'a aidé à visualiser l'idée derrière l'indice de Gini et, finalement, à mieux comprendre comment fonctionne un modèle d'arbre.

Implémentation d'un arbre de classification avec Scikit-Learn

Dans la section suivante, j'écrirai du code pour démontrer une application facile d'un arbre de classification sur le jeu de données Iris bien connu. Ceci est facilement accessible via Scikit-Learn et est prêt à être travaillé:

from sklearn import datasets
iris = datasets.load_iris()

Commençons à importer tous les modules :

import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

df = pd.read_csv("Desktop/Iris.csv")
print(df)

      

       Fig 2— Iris dataset
      

Pour utiliser nos fonctionnalités, nous devons créer une matrice X où chaque ligne représente une instance et chaque colonne une fonctionnalité. Nous pouvons y parvenir avec un tableau numpy qui prend les données des colonnes d'intérêt, puis les transpose. Nous devons également créer un vecteur colonne y qui est notre variable cible (les espèces de fleurs) :

X = np.array([df.SepalLengthCm, df.SepalWidthCm, df.PetalLengthCm, df.PetalWidthCm]).T
y = np.array(df.Species).reshape(-1,1)
print(X.shape) -> Out: (150, 4)
print(y.shape) -> Out: (150, 1)

Une fois que nous avons bien organisé nos données, nous pouvons continuer et créer notre classificateur d'arbre de décision :

dtc = DecisionTreeClassifier(max_depth = 4, random_state=0)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

dtc = dtc.fit(X_train, y_train)

score = dtc.score(X_test, y_test)
print(score) -> Out: 0.9736842105263158

Voici à quoi ressemble notre arbre

fn=['sepal length','sepal width ','petal length ','petal width ']
cn=['Setosa', 'Versicolor', 'Virginica']
plt.figure(figsize=(10,10))
tree.plot_tree(dtc, feature_names = fn, class_names=cn, filled = True)

      

       Fig 3 — Our classification tree
      

Étant donné une nouvelle fleur (instance), nous pouvons commencer à prédire son espèce (classe) comme suit :

new_flower = np.array([5.5, 2.8, 5, 2]).reshape(1,-1)
prediction = dtc.predict(new_flower)
print(prediction) -> Out: 'Iris-virginica'

Les arbres de décision peuvent être ajustés (leurs hyperparamètres ), boostés et également combinés pour créer des forêts aléatoires. Ce n'est pas fini…

Code à un arbre de décision de base

Au total, le code pour implémenter cet arbre de classification est :

import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
df = pd.read_csv("Desktop/Iris.csv")
X = np.array([df.SepalLengthCm, df.SepalWidthCm, df.PetalLengthCm, df.PetalWidthCm]).T
y = np.array(df.Species).reshape(-1,1)
dtc = DecisionTreeClassifier(max_depth = 4, random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
dtc = dtc.fit(X_train, y_train)
score = dtc.score(X_test, y_test) 
print(score)