Accéder au contenu principal

Tutoriel sur la classification par arbre de décision en Python

Dans ce tutoriel, vous apprendrez la classification par arbre de décision, les mesures de sélection des attributs et comment construire et optimiser un classificateur par arbre de décision à l'aide du package Python Scikit-learn.
Actualisé 4 oct. 2024  · 12 min de lecture

En tant que responsable marketing, vous souhaitez disposer d'un ensemble de clients susceptibles d'acheter votre produit. C'est ainsi que vous pouvez économiser votre budget marketing en trouvant votre public. En tant que gestionnaire de prêts, vous devez identifier les demandes de prêts à risque afin de réduire le taux de défaillance des prêts. Ce processus de classification des clients en un groupe de clients potentiels et non potentiels ou de demandes de prêt sûres ou risquées est connu sous le nom de problème de classification.

La classification est un processus en deux étapes : une étape d'apprentissage et une étape de prédiction. Lors de l'étape d'apprentissage, le modèle est développé sur la base de données d'apprentissage données. Dans l'étape de prédiction, le modèle est utilisé pour prédire la réponse à des données données. Un arbre de décision est l'un des algorithmes de classification les plus simples et les plus populaires utilisés pour comprendre et interpréter les données. Il peut être utilisé pour les problèmes de classification et de régression.

Pour exécuter facilement vous-même tous les exemples de code de ce tutoriel, vous pouvez créer gratuitement un classeur DataLab dans lequel Python est préinstallé et qui contient tous les exemples de code. Pour une explication vidéo sur la classification par arbre de décision, regardez cette vidéo du cours DataCamp.

Devenez un scientifique ML

Maîtriser Python pour devenir un scientifique de l'apprentissage automatique

L'algorithme de l'arbre de décision

Un arbre de décision est une structure arborescente de type organigramme dans laquelle un nœud interne représente une caractéristique (ou un attribut), la branche représente une règle de décision et chaque nœud feuille représente le résultat.

Le nœud le plus élevé d'un arbre de décision est appelé nœud racine. Il apprend à partitionner sur la base de la valeur de l'attribut. Il partitionne l'arbre de manière récursive, appelée partition récursive. Cette structure en forme d'organigramme vous aide à prendre des décisions. Il s'agit d'une visualisation sous forme d'organigramme qui imite facilement la pensée humaine. C'est pourquoi les arbres de décision sont faciles à comprendre et à interpréter.

exemple d'arbre de décision pour la prévention des crises cardiaques

Image | Abid Ali Awan 

Un arbre de décision est un type d'algorithme ML à boîte blanche. Il partage la logique interne de prise de décision, qui n'est pas disponible dans les algorithmes de type "boîte noire" tels que les réseaux neuronaux. Son temps d'apprentissage est plus rapide que celui de l'algorithme du réseau neuronal.

La complexité temporelle des arbres de décision est fonction du nombre d'enregistrements et d'attributs dans les données données données. L'arbre de décision est une méthode sans distribution ou non paramétrique qui ne dépend pas d'hypothèses de distribution de probabilité. Les arbres de décision peuvent traiter des données de haute dimension avec une bonne précision.

Comment fonctionne l'algorithme de l'arbre de décision ?

L'idée de base de tout algorithme d'arbre de décision est la suivante :

  1. Sélectionnez le meilleur attribut à l'aide des mesures de sélection d'attributs (ASM) pour diviser les enregistrements.
  2. Faites de cet attribut un nœud de décision et divisez l'ensemble de données en sous-ensembles plus petits.
  3. Commencez à construire l'arbre en répétant ce processus de manière récursive pour chaque enfant jusqu'à ce que l'une des conditions corresponde :
    • Tous les tuples appartiennent à la même valeur d'attribut.
    • Il ne reste plus d'attributs.
    • Il n'y a plus d'instances.
Comment fonctionne l'algorithme de l'arbre de décision ?

Mesures de sélection des attributs

La mesure de sélection des attributs est une heuristique permettant de sélectionner le critère de division qui partitionne les données de la meilleure manière possible. Elle est également connue sous le nom de règles de division, car elle nous aide à déterminer les points de rupture pour les tuples sur un nœud donné. L'ASM attribue un rang à chaque caractéristique (ou attribut) en expliquant l'ensemble de données donné. L'attribut ayant obtenu le meilleur score sera sélectionné comme attribut de fractionnement(Source). Dans le cas d'un attribut à valeur continue, les points de séparation des branches doivent également être définis. Les mesures de sélection les plus courantes sont le gain d'information, le ratio de gain et l'indice de Gini.

Gain d'information

Claude Shannon a inventé le concept d'entropie, qui mesure l'impureté d'un ensemble d'entrées. En physique et en mathématiques, l'entropie désigne le caractère aléatoire ou l'impureté d'un système. En théorie de l'information, il s'agit de l'impureté d'un groupe d'exemples. Le gain d'information est la diminution de l'entropie. Le gain d'information calcule la différence entre l'entropie avant la scission et l'entropie moyenne après la scission de l'ensemble de données sur la base de valeurs d'attributs données. L'algorithme d'arbre de décision ID3 (Iterative Dichotomiser) utilise le gain d'information.

gain d'informations

Où Pi est la probabilité qu'un tuple arbitraire dans D appartienne à la classe Ci.

gain d'information
gain d'informations

Où ?

  • Info(D) est la quantité moyenne d'informations nécessaires pour identifier l'étiquette de classe d'un tuple dans D.
  • |Dj|/|D| représente le poids de la jème partition.
  • InfoA(D) est l'information attendue nécessaire pour classer un tuple de D sur la base du partitionnement par A.

L'attribut A ayant le gain d'information le plus élevé, Gain(A), est choisi comme attribut de séparation au nœud N().

Rapport de gain

Le gain d'information est biaisé pour l'attribut ayant de nombreux résultats. Cela signifie qu'il préfère l'attribut ayant un grand nombre de valeurs distinctes. Prenons l'exemple d'un attribut doté d'un identifiant unique, tel que customer_ID, dont l'info(D) est nulle en raison d'une partition pure. Cela permet de maximiser le gain d'informations et de créer un cloisonnement inutile.

C4.5, une amélioration de ID3, utilise une extension du gain d'information connue sous le nom de ratio de gain. Le rapport de gain traite la question du biais en normalisant le gain d'information à l'aide de Split Info. L'implémentation Java de l'algorithme C4.5 est connue sous le nom de J48, qui est disponible dans l'outil d'exploration de données WEKA.

Rapport de gain

Où ?

  • |Dj|/|D| représente le poids de la jème partition.
  • v est le nombre de valeurs discrètes de l'attribut A.

Le rapport de gain peut être défini comme suit

Rapport de gain

L'attribut présentant le rapport de gain le plus élevé est choisi comme attribut de séparation(Source).

Indice de Gini

Un autre algorithme d'arbre de décision, CART (Classification and Regression Tree), utilise la méthode de Gini pour créer des points de séparation.

Indice de Gini

Où pi est la probabilité qu'un tuple de D appartienne à la classe Ci.

L'indice de Gini considère une répartition binaire pour chaque attribut. Vous pouvez calculer une somme pondérée de l'impureté de chaque partition. Si une division binaire sur l'attribut A divise les données D en D1 et D2, l'indice de Gini de D est :

Indice de Gini

Dans le cas d'un attribut à valeur discrète, le sous-ensemble qui donne l'indice de Gini minimum pour cet attribut choisi est sélectionné comme attribut de séparation. Dans le cas d'attributs à valeur continue, la stratégie consiste à sélectionner chaque paire de valeurs adjacentes comme point de séparation possible, et le point ayant un indice de Gini plus petit est choisi comme point de séparation.

indice de gini

L'attribut ayant l'indice de Gini le plus faible est choisi comme attribut de séparation.

Exécutez et modifiez le code de ce tutoriel en ligne

Exécuter le code

Construction d'un classificateur par arbre de décision dans Scikit-learn

Importation des bibliothèques requises

Commençons par charger les bibliothèques nécessaires.

# Load libraries
import pandas as pd
from sklearn.tree import DecisionTreeClassifier # Import Decision Tree Classifier
from sklearn.model_selection import train_test_split # Import train_test_split function
from sklearn import metrics #Import scikit-learn metrics module for accuracy calculation

Chargement des données

Commençons par charger le jeu de données Pima Indian Diabetes requis à l'aide de la fonction read CSV de pandas. Vous pouvez télécharger l'ensemble de données Kaggle pour suivre le processus.

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
# load dataset
pima = pd.read_csv("diabetes.csv", header=None, names=col_names)
pima.head()
  enceinte glucose bp skin l'insuline bmi pedigree âge étiquette
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1

Sélection des caractéristiques

Ici, vous devez diviser les colonnes données en deux types de variables : la variable dépendante (ou variable cible) et la variable indépendante (ou variable caractéristique).

#split dataset in features and target variable
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

Fractionnement des données

Pour comprendre les performances d'un modèle, la division de l'ensemble de données en un ensemble d'apprentissage et un ensemble de test est une bonne stratégie.

Divisons l'ensemble de données en utilisant la fonction train_test_split(). Vous devez passer trois paramètres : caractéristiques, cible et taille de l'ensemble de tests.

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1) # 70% training and 30% test

Construction d'un modèle d'arbre de décision

Créons un modèle d'arbre de décision à l'aide de Scikit-learn.

# Create Decision Tree classifer object
clf = DecisionTreeClassifier()

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

Évaluation du modèle

Estimons la précision avec laquelle le classificateur ou le modèle peut prédire le type de cultivars.

La précision peut être calculée en comparant les valeurs réelles de l'ensemble de tests et les valeurs prédites.

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
Accuracy: 0.6753246753246753

Nous avons obtenu un taux de classification de 67,53 %, ce qui est considéré comme une bonne précision. Vous pouvez améliorer cette précision en réglant les paramètres de l'algorithme de l'arbre de décision.

Visualisation des arbres de décision

Vous pouvez utiliser la fonction export_graphviz de Scikit-learn pour afficher l'arbre dans un carnet Jupyter. Pour tracer l'arbre, vous devez également installer graphviz et pydotplus.

pip install graphviz

pip install pydotplus

La fonction export_graphviz convertit le classificateur d'arbre de décision en un fichier point, et pydotplus convertit ce fichier point en png ou en une forme affichable sur Jupyter.

from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO  
from IPython.display import Image  
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
graph.write_png('diabetes.png')
Image(graph.create_png())
Visualisation des arbres de décision

Dans l'arbre de décision, chaque nœud interne comporte une règle de décision qui divise les données. Gini, appelé ratio de Gini, mesure l'impureté du nœud. On peut dire qu'un nœud est pur lorsque tous ses enregistrements appartiennent à la même classe, ces nœuds étant appelés nœuds feuilles.

Ici, l'arbre résultant n'est pas élagué. Cet arbre non taillé est inexplicable et difficilement compréhensible. Dans la section suivante, nous allons l'optimiser en l'élaguant.

Optimiser les performances des arbres de décision

  • criterion : optionnel (default="gini") ou Choisissez la mesure de sélection des attributs. Ce paramètre nous permet d'utiliser la mesure de sélection d'attributs différents. Les critères pris en charge sont "gini" pour l'indice de Gini et "entropie" pour le gain d'information.

  • splitter : chaîne, optionnelle (default="best") ou Stratégie de fractionnement. Ce paramètre nous permet de choisir la stratégie de fractionnement. Les stratégies prises en charge sont "best" pour choisir la meilleure répartition et "random" pour choisir la meilleure répartition aléatoire.

  • max_depth : int ou None, optionnel (default=None) ou Profondeur maximale d'un arbre. La profondeur maximale de l'arbre. Si None, les nœuds sont développés jusqu'à ce que toutes les feuilles contiennent moins que min_samples_split samples. La valeur la plus élevée de la profondeur maximale entraîne un surajustement, et une valeur plus faible un sous-ajustement(Source).

Dans Scikit-learn, l'optimisation du classificateur à arbre de décision est réalisée uniquement par pré-élagage. La profondeur maximale de l'arbre peut être utilisée comme variable de contrôle pour la pré-taille. Dans l'exemple suivant, vous pouvez tracer un arbre de décision sur les mêmes données avec max_depth=3. Outre les paramètres de pré-élagage, vous pouvez également essayer d'autres mesures de sélection d'attributs telles que l'entropie.

# Create Decision Tree classifer object
clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
Accuracy: 0.7705627705627706

Le taux de classification est passé à 77,05 %, ce qui représente une meilleure précision que le modèle précédent.

Visualisation des arbres de décision

Rendons notre arbre de décision un peu plus facile à comprendre en utilisant le code suivant : 

from six import StringIO from IPython.display import Image from sklearn.tree import export_graphviz import pydotplus dot_data = StringIO() export_graphviz(clf, out_file=dot_data, filled=True, rounded=True, special_characters=True, feature_names = feature_cols,class_names=['0','1']) graph = pydotplus.graph_from_dot_data(dot_data.getvalue()) graph.write_png('diabetes.png') Image(graph.create_png())

Ici, nous avons effectué les étapes suivantes : 

  • Importer les bibliothèques nécessaires.
  • Création d'un objet StringIO appelé dot_data pour contenir la représentation textuelle de l'arbre de décision.
  • Exportation de l'arbre de décision au format dot à l'aide de la fonction export_graphviz et écriture de la sortie dans le tampon dot_data.
  • Création d'un objet graphique pydotplus à partir de la représentation au format dot de l'arbre de décision stocké dans la mémoire tampon dot_data.
  • Inscrivez le graphique généré dans un fichier PNG nommé "diabetes.png".
  • Affichage de l'image PNG générée de l'arbre de décision à l'aide de l'objet Image du module IPython.display.
Visualisation des arbres de décision

Comme vous pouvez le constater, ce modèle élagué est moins complexe, plus explicable et plus facile à comprendre que le modèle d'arbre de décision précédent.

Les pros de l'arbre de décision

  • Les arbres de décision sont faciles à interpréter et à visualiser.
  • Il peut facilement capturer des modèles non linéaires.
  • Il nécessite moins de prétraitement des données de la part de l'utilisateur, par exemple, il n'est pas nécessaire de normaliser les colonnes.
  • Il peut être utilisé pour l'ingénierie des caractéristiques, par exemple pour prédire les valeurs manquantes ou pour la sélection des variables.
  • L'arbre de décision ne repose sur aucune hypothèse de distribution en raison de la nature non paramétrique de l'algorithme. (Source)

Arbre de décision Cons

  • Sensible aux données bruyantes. Il peut suradapter des données bruyantes.
  • La petite variation (ou variance) des données peut donner lieu à un arbre de décision différent. Ce phénomène peut être réduit grâce aux algorithmes de bagging et de boosting.
  • Les arbres de décision sont biaisés lorsque les données sont déséquilibrées. Il est donc recommandé d'équilibrer les données avant de créer l'arbre de décision.

Conclusion

Félicitations, vous avez atteint la fin de ce tutoriel !

Dans ce tutoriel, vous avez abordé de nombreux détails sur les arbres de décision, leur fonctionnement, les mesures de sélection d'attributs telles que le gain d'information, le ratio de gain et l'indice de Gini, la construction de modèles d'arbres de décision, la visualisation et l'évaluation d'un ensemble de données sur le diabète à l'aide du paquet Scikit-learn de Python. Nous avons également discuté de ses avantages et de ses inconvénients, ainsi que de la manière d'optimiser les performances de l'arbre de décision à l'aide de l'ajustement des paramètres.

Nous espérons que vous pouvez maintenant utiliser l'algorithme de l'arbre de décision pour analyser vos propres ensembles de données.

Si vous souhaitez en savoir plus sur l'apprentissage automatique en Python, suivez la formation Machine Learning with Tree-Based Models in Python de DataCamp.

Consultez notre Tutoriel Kaggle : Votre premier modèle d'apprentissage automatique.

Obtenez une certification dans le rôle de Data Scientist de vos rêves

Nos programmes de certification vous aident à vous démarquer et à prouver aux employeurs potentiels que vos compétences sont adaptées à l'emploi.

Obtenez votre certification
Timeline mobile.png

FAQ sur la classification par arbre de décision

Quels sont les cas d'utilisation courants de la classification par arbre de décision ?

La classification par arbre de décision est couramment utilisée dans divers domaines tels que la finance pour l'évaluation du crédit, la santé pour le diagnostic des maladies, le marketing pour la segmentation de la clientèle, etc. Il aide à prendre des décisions en divisant les données en sous-ensembles basés sur différents critères.

Comment éviter l'overfitting lors de l'utilisation d'arbres de décision ?

L'ajustement excessif peut être évité en élaguant l'arbre, en fixant une profondeur maximale, en utilisant un nombre minimal d'échantillons requis pour diviser un nœud interne et en utilisant un nombre minimal d'échantillons requis pour se trouver à un nœud feuille. La validation croisée peut également aider à régler ces paramètres de manière efficace.

Quelle est la différence entre un arbre de décision et une forêt aléatoire ?

Un arbre de décision est une structure arborescente unique utilisée pour la classification ou la régression. Une forêt aléatoire, en revanche, est un ensemble d'arbres de décision multiples, qui améliore la précision de la prédiction et contrôle l'ajustement excessif en faisant la moyenne des résultats de plusieurs arbres.

Comment gérer les valeurs manquantes dans mon ensemble de données lorsque j'utilise des arbres de décision ?

Les arbres de décision peuvent traiter les valeurs manquantes en utilisant des divisions de substitution ou en remplaçant les valeurs manquantes par la valeur la plus fréquente ou la moyenne/mode de la caractéristique. Scikit-learn propose également des méthodes telles que SimpleImputer pour combler les valeurs manquantes avant d'entraîner le modèle.

Quels sont les avantages de l'utilisation de Scikit-learn pour la construction de modèles d'arbres de décision ?

Scikit-learn fournit un outil simple et efficace pour l'exploration et l'analyse des données, y compris les classificateurs d'arbres de décision. Il offre diverses fonctionnalités telles qu'une intégration facile, une documentation complète, la prise en charge de diverses métriques et de l'ajustement des paramètres, ainsi que des méthodes de visualisation des arbres de décision, ce qui en fait un choix populaire pour les praticiens de l'apprentissage automatique.

Sujets

Cours Python

Certification disponible

cours

Introduction à Python

4 hr
5.7M
Maîtrisez les bases de l'analyse de données avec Python en seulement quatre heures. Ce cours en ligne présente l'interface Python et explore les paquets les plus courants.
Afficher les détailsRight Arrow
Commencer le cours
Voir plusRight Arrow