TechCodeview

• L'arbre de décision est un Technique d'apprentissage supervisé qui peut être utilisé à la fois pour les problèmes de classification et de régression, mais il est surtout préféré pour résoudre les problèmes de classification. Il s'agit d'un classificateur arborescent, où les nœuds internes représentent les caractéristiques d'un ensemble de données, les branches représentent les règles de décision et chaque nœud feuille représente le résultat.
• Dans un arbre de décision, il y a deux nœuds, qui sont les Nœud de décision et Noeud feuille. Les nœuds de décision sont utilisés pour prendre n'importe quelle décision et ont plusieurs branches, tandis que les nœuds feuilles sont le résultat de ces décisions et ne contiennent aucune autre branche.
• Les décisions ou le test sont effectués sur la base des caractéristiques de l'ensemble de données donné.
Il s'agit d'une représentation graphique permettant d'obtenir toutes les solutions possibles à un problème/une décision basée sur des conditions données.
• On l'appelle arbre de décision car, semblable à un arbre, il commence par le nœud racine, qui se développe sur d'autres branches et construit une structure arborescente.
• Pour construire un arbre, nous utilisons le Algorithme CART, Qui veut dire Algorithme d’arbre de classification et de régression.
• Un arbre de décision pose simplement une question et, en fonction de la réponse (Oui/Non), il divise l'arbre en sous-arbres.
• Le diagramme ci-dessous explique la structure générale d'un arbre de décision :

Remarque : Un arbre de décision peut contenir des données catégorielles (OUI/NON) ainsi que des données numériques.

Pourquoi utiliser des arbres de décision ?

Il existe différents algorithmes dans l'apprentissage automatique, donc choisir le meilleur algorithme pour l'ensemble de données et le problème donnés est le point principal à retenir lors de la création d'un modèle d'apprentissage automatique. Vous trouverez ci-dessous les deux raisons d'utiliser l'arbre de décision :

• Les arbres de décision imitent généralement la capacité de réflexion humaine lors de la prise de décision, ils sont donc faciles à comprendre.
• La logique derrière l’arbre de décision peut être facilement comprise car elle présente une structure arborescente.

Terminologies des arbres de décision

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

chaîne comparer java

Dans un arbre de décision, pour prédire la classe de l'ensemble de données donné, l'algorithme part du nœud racine de l'arbre. Cet algorithme compare les valeurs de l'attribut racine avec l'attribut d'enregistrement (ensemble de données réel) et, sur la base de la comparaison, suit la branche et passe au nœud suivant.

Pour le nœud suivant, l'algorithme compare à nouveau la valeur de l'attribut avec les autres sous-nœuds et va plus loin. Il continue le processus jusqu'à ce qu'il atteigne le nœud feuille de l'arbre. Le processus complet peut être mieux compris à l’aide de l’algorithme ci-dessous :

Étape 1:Commencez l'arborescence par le nœud racine, dit S, qui contient l'ensemble de données complet.Étape 2:Trouvez le meilleur attribut de l'ensemble de données en utilisant Mesure de sélection d'attribut (ASM). Étape 3:Divisez le S en sous-ensembles contenant les valeurs possibles pour les meilleurs attributs.Étape 4:Générez le nœud de l'arbre de décision qui contient le meilleur attribut.Étape 5 :Créez de manière récursive de nouveaux arbres de décision en utilisant les sous-ensembles de l'ensemble de données créé à l'étape -3. Continuez ce processus jusqu'à ce qu'une étape soit atteinte où vous ne pouvez pas classer davantage les nœuds et appeler le nœud final en tant que nœud feuille.

Exemple: Supposons qu'un candidat ait une offre d'emploi et souhaite décider s'il doit accepter l'offre ou non. Ainsi, pour résoudre ce problème, l’arbre de décision commence par le nœud racine (attribut Salaire par ASM). Le nœud racine se divise en un nœud de décision suivant (distance du bureau) et un nœud feuille en fonction des étiquettes correspondantes. Le nœud de décision suivant est ensuite divisé en un nœud de décision (installation Cab) et un nœud feuille. Enfin, le nœud de décision se divise en deux nœuds feuilles (offres acceptées et offre refusée). Considérez le diagramme ci-dessous :

Mesures de sélection des attributs

Lors de la mise en œuvre d'un arbre de décision, le principal problème se pose : comment sélectionner le meilleur attribut pour le nœud racine et pour les sous-nœuds. Ainsi, pour résoudre de tels problèmes, il existe une technique appelée Mesure de sélection d'attribut ou ASM. Grâce à cette mesure, nous pouvons facilement sélectionner le meilleur attribut pour les nœuds de l’arbre. Il existe deux techniques populaires pour l'ASM, à savoir :

Gain d'informations Indice de Gini

1. Gain d'informations :

• Le gain d'information est la mesure des changements d'entropie après la segmentation d'un ensemble de données basée sur un attribut.
• Il calcule la quantité d'informations qu'une fonctionnalité nous fournit sur une classe.
• En fonction de la valeur du gain d'informations, nous divisons le nœud et construisons l'arbre de décision.
• Un algorithme d'arbre de décision essaie toujours de maximiser la valeur du gain d'informations, et un nœud/attribut ayant le gain d'informations le plus élevé est divisé en premier. Il peut être calculé à l'aide de la formule ci-dessous :

 Information Gain= Entropy(S)- [(Weighted Avg) *Entropy(each feature) 

Entropie : L'entropie est une métrique permettant de mesurer l'impureté dans un attribut donné. Il spécifie le caractère aléatoire des données. L'entropie peut être calculée comme suit :

Entropy(s)= -P(yes)log2 P(yes)- P(no) log2 P(no)

Où,

S= Nombre total d'échantillons P(oui)= probabilité de oui P(non)= probabilité de non

2. Indice de Gini :

• L'indice de Gini est une mesure d'impureté ou de pureté utilisée lors de la création d'un arbre de décision dans l'algorithme CART (Classification and Regression Tree).
• Un attribut avec un indice de Gini faible doit être préféré par rapport à un indice de Gini élevé.
• Il crée uniquement des divisions binaires et l'algorithme CART utilise l'index Gini pour créer des divisions binaires.
• L'indice de Gini peut être calculé à l'aide de la formule ci-dessous :

 Gini Index= 1- &#x2211;<sub>j</sub>P<sub>j</sub><sup>2</sup> 

Élagage : obtenir un arbre de décision optimal

L'élagage est un processus de suppression des nœuds inutiles d'un arbre afin d'obtenir l'arbre de décision optimal.

Un arbre trop grand augmente le risque de surajustement, et un petit arbre peut ne pas capturer toutes les caractéristiques importantes de l'ensemble de données. Par conséquent, une technique qui réduit la taille de l’arbre d’apprentissage sans réduire la précision est connue sous le nom d’élagage. Il existe principalement deux types d'arbres taille technologie utilisée :

Élagage de la complexité des coûts Élagage d’erreur réduit.

Avantages de l'arbre de décision

• Il est simple à comprendre car il suit le même processus qu’un humain suit lorsqu’il prend une décision dans la vie réelle.
• Cela peut être très utile pour résoudre des problèmes liés à la décision.
• Il est utile de réfléchir à toutes les conséquences possibles d’un problème.
• Il y a moins d’exigences de nettoyage des données par rapport aux autres algorithmes.

Inconvénients de l'arbre de décision

• L’arbre de décision contient de nombreuses couches, ce qui le rend complexe.
• Il peut y avoir un problème de surajustement, qui peut être résolu à l'aide du Algorithme de forêt aléatoire.
• Pour plus d’étiquettes de classe, la complexité informatique de l’arbre de décision peut augmenter.

Implémentation Python de l'arbre de décision

Nous allons maintenant implémenter l'arbre de décision en utilisant Python. Pour cela, nous utiliserons le jeu de données ' user_data.csv ', que nous avons utilisé dans les modèles de classification précédents. En utilisant le même ensemble de données, nous pouvons comparer le classificateur d'arbre de décision avec d'autres modèles de classification tels que KNN SVM, Régression Logistique, etc.

Les étapes resteront également les mêmes, qui sont indiquées ci-dessous :

Étape de prétraitement des données Ajustement d'un algorithme d'arbre de décision à l'ensemble de formation Prédire le résultat du test Test de précision du résultat (Création d'une matrice de confusion) Visualisation du résultat de l'ensemble de test.

1. Étape de prétraitement des données :

Vous trouverez ci-dessous le code de l'étape de pré-traitement :

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

Dans le code ci-dessus, nous avons prétraité les données. Où nous avons chargé l'ensemble de données, qui est donné comme suit :

2. Ajustement d'un algorithme d'arbre de décision à l'ensemble de formation

Nous allons maintenant adapter le modèle à l'ensemble de formation. Pour cela, nous importerons le Classificateur d'arbre de décision classe de sklearn.tree bibliothèque. Ci-dessous le code correspondant :

 #Fitting Decision Tree classifier to the training set From sklearn.tree import DecisionTreeClassifier classifier= DecisionTreeClassifier(criterion='entropy', random_state=0) classifier.fit(x_train, y_train) 

Dans le code ci-dessus, nous avons créé un objet classificateur, dans lequel nous avons passé deux paramètres principaux ;

'critère='entropie' :Le critère est utilisé pour mesurer la qualité de la division, qui est calculée par le gain d'informations fourni par l'entropie.état_aléatoire=0' :Pour générer les états aléatoires.

Voici le résultat de ceci :

 Out[8]: DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None, max_features=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, presort=False, random_state=0, splitter='best') 

3. Prédire le résultat du test

Nous allons maintenant prédire le résultat de l’ensemble de test. Nous allons créer un nouveau vecteur de prédiction y_pred. Ci-dessous le code correspondant :

 #Predicting the test set result y_pred= classifier.predict(x_test) 

Sortir:

Dans l'image de sortie ci-dessous, la sortie prévue et la sortie réelle du test sont données. Nous pouvons clairement voir que certaines valeurs dans le vecteur de prédiction sont différentes des valeurs réelles du vecteur. Ce sont des erreurs de prédiction.

taille a-b

4. Tester l'exactitude du résultat (Création d'une matrice de confusion)

Dans le résultat ci-dessus, nous avons vu qu'il y avait des prédictions incorrectes, donc si nous voulons connaître le nombre de prédictions correctes et incorrectes, nous devons utiliser la matrice de confusion. Ci-dessous le code correspondant :

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

Sortir:

Dans l’image de sortie ci-dessus, nous pouvons voir la matrice de confusion, qui a 6+3= 9 prédictions incorrectes et 62+29=91 prédictions correctes. Par conséquent, nous pouvons dire que par rapport à d’autres modèles de classification, le classificateur Decision Tree a fait une bonne prédiction.

5. Visualisation du résultat de l'ensemble d'entraînement :

Ici, nous allons visualiser le résultat de l'ensemble de formation. Pour visualiser le résultat de l'ensemble de formation, nous tracerons un graphique pour le classificateur d'arbre de décision. Le classificateur prédira oui ou non pour les utilisateurs qui ont acheté ou non la voiture SUV, comme nous l'avons fait dans la régression logistique. Ci-dessous le code correspondant :

 #Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) fori, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Decision Tree Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Sortir:

Le résultat ci-dessus est complètement différent des autres modèles de classification. Il comporte des lignes verticales et horizontales qui divisent l'ensemble de données en fonction de la variable d'âge et de salaire estimé.

Comme nous pouvons le voir, l'arbre essaie de capturer chaque ensemble de données, ce qui est le cas du surajustement.

6. Visualisation du résultat de l'ensemble de test :

La visualisation du résultat de l'ensemble de test sera similaire à la visualisation de l'ensemble de formation, sauf que l'ensemble de formation sera remplacé par l'ensemble de test.

 #Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) fori, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Decision Tree Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Sortir:

Comme nous pouvons le voir sur l’image ci-dessus, il existe des points de données verts dans la région violette et vice versa. Ce sont donc les prédictions incorrectes dont nous avons discuté dans la matrice de confusion.