2. Analyse multivariée décrite dans Python 7-1. Arbre de décision (scikit-learn)

• L'arbre de décision est également appelé arbre de décision.
• Afin d'atteindre un certain objectif, il s'agit d'une méthode de classification en répétant le branchement basé sur chaque attribut (variable explicative) des données. Il est nommé arbre pour la décision, après que le processus est montré dans le dendrogramme dans son ensemble.
• Lorsque la variable objective ciblée pour la classification est des données catégorielles, on l'appelle ** arbre de classification **, et lorsqu'il s'agit de données numériques, on l'appelle ** arbre de régression **.

** Ici, passons d'abord par un exemple d'arbre de classification. ** **

⑴ Bibliothèque d'importation

#Classe pour construire un modèle d'arbre de décision
from sklearn.tree import DecisionTreeClassifier
#Module basé sur le modèle d'arbre de décision
from sklearn import tree

#Ensemble de données pour l'apprentissage automatique
from sklearn import datasets
#Utilitaire de fractionnement des données
from sklearn.model_selection import train_test_split

#Module pour afficher des images dans Notebook
from IPython.display import Image  
#Module de visualisation du modèle d'arbre de décision
import pydotplus

⑵ Acquisition et lecture de données

iris = datasets.load_iris()
print(iris)

• C'est un jeu de données très connu, mais il semble nouveau, mais c'est un jeu de données qui stocke 4 quantités de caractéristiques qui mesurent la longueur et la largeur des "pétales" et "gaku" de 3 types d'iris.
• Les trois types sont des données de catégorie de Setosa, Versicolour et Virginica, avec 50 échantillons pour chaque type, pour un total de 150 échantillons.
• Cliquez ici pour l'explication officielle de scikit-learn, https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html

• Le contenu de l'ensemble de données iris se compose de cinq parties: le libellé et les données de la variable explicative (quantité de caractéristiques), le libellé et les données de la variable objectif (type), et le contour des données.
• Juste au cas où, vérifiez comment les données sont stockées.

#Libellé de la variable explicative
print(iris.feature_names)

#Forme variable explicative
print(iris.data.shape)

#Afficher les 5 premières lignes de la variable explicative
iris.data[0:5, :]

• Un total de 150 échantillons avec 4 valeurs mesurées comme variables explicatives.

• Ensuite, les variables objectives sont stockées sous forme de variables catégorielles avec trois types [0, 1, 2].

#Libellé de la variable d'objectif
print(iris.target_names)

#Forme de la variable objective
print(iris.target.shape)

#Afficher la variable objective
iris.target

(3) Prétraitement des données

#Stocker respectivement les variables explicatives et les variables objectives
X = iris.data
y = iris.target

#Séparé pour la formation et les tests
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

• Sauf si vous spécifiez un ratio d'allocation spécifique, il sera divisé aléatoirement à un ratio de 75% pour la formation et de 25% pour les tests par défaut.
• En spécifiant random_state = 0 dans l'argument, le premier état de fractionnement sera reproduit quel que soit le nombre de fois que le fractionnement est répété.

⑷ Construction du modèle et évaluation de l'arbre de décision

#Initialiser la classe qui construit le modèle d'arbre de décision
clf = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=0)

#Générer un modèle d'arbre de décision
model = clf.fit(X_train, y_train)

#Calculez le taux de réponse correct pour chaque formation et test
print('Taux de réponse correct(train):{:.3f}'.format(model.score(X_train, y_train)))
print('Taux de réponse correct(test):{:.3f}'.format(model.score(X_test, y_test)))

• La base du processus de génération de l'arbre de décision est l'indice ** impur ** d'identification de catégorie. S'il est de 0,0, cela signifie qu'il est purement classé en fonction de la quantité d'impuretés mélangées.
• C'est pourquoi l'argument dit critère = 'gini', qui spécifie explicitement ** les impuretés de Gini **. (La valeur par défaut est Gini Impure, il n'est donc pas nécessaire de la décrire.)
• De plus, ** Profondeur de la hiérarchie des branches conditionnelles ** est spécifiée comme max_depth = 3 dans cet exemple, jusqu'à 3 couches au maximum. Augmenter le nombre de hiérarchies à un «arbre profond» augmentera le taux de précision, mais cela peut également augmenter le risque de surapprentissage.
• Pour le modèle généré, calculez le taux de réponse correct pour chaque entraînement et testez avec la fonction score (). Les données d'entraînement sont très élevées à 0,982 et les données de test sont légèrement inférieures à cela, mais les deux sont proches de 1,0 et élevés.

⑸ Dessiner un diagramme en arbre

• Le dessin du diagramme est les 3 étapes suivantes.

1. ** Convertir le modèle d'arbre de décision en données DOT **
2. ** Dessinez un diagramme à partir des données DOT **
3. ** Convertir en png et afficher dans Notebook **

#Convertir le modèle d'arbre de décision en données DOT
dot_data = tree.export_graphviz(model,                              #Spécifiez le modèle d'arbre de décision
                                out_file = None,                    #Spécifie de renvoyer une chaîne au lieu d'un fichier de sortie
                                feature_names = iris.feature_names, #Spécifiez le nom d'affichage du montant de la fonction
                                class_names = iris.target_names,    #Spécifiez le nom d'affichage de la classification
                                filled = True)                      #Nœuds de couleur dans la classe majoritaire

#Dessinez un diagramme
graph = pydotplus.graph_from_dot_data(dot_data)  

#Afficher le diagramme
Image(graph.create_png())

• ** Les données DOT ** sont des données écrites dans le langage DOT. ** Le langage DOT ** est un langage pour décrire les structures de graphes (structures de réseau constituées de nœuds et d'arêtes). Un nœud signifie un nœud (□) et une arête signifie une ligne de connexion (↓).
• Un outil pour dessiner de telles structures graphiques est ** Graphviz **. La fonction ʻexport_graphviz () `, qui appartient au module arbre de sklearn, convertit le modèle d'arbre de décision au format DOT. À ce moment-là, les spécifications détaillées telles que les spécifications de dessin et le nom d'affichage sont spécifiées en tant qu'arguments.
• Ensuite, dessinez un graphe en utilisant la fonction graph_from_dot_data () du module ** pydotplus ** pour gérer le langage DOT en Python.
• De plus, pour afficher le graphique dans Notebook, je convertis le graphique en png et j'exécute la méthode ʻImage ()` du module ** IPython.display **.

Comment lire un diagramme en arbre

• L'arbre de décision sera vu d'en haut. Tout d'abord, les conditions de classification valides ➀ partent d'ici.
• L'expression conditionnelle «largeur des pétales (cm) <= 0,8» signifie que la largeur des pétales est de 0,8 ou moins. Le cas échéant, suivez la flèche de «Vrai», sinon suivez la flèche de «Faux».
• Les nœuds qui descendent de la flèche «Vrai» montrent une ** impureté Gini de 0,0 **, et les 37 échantillons sont purement classés comme des espèces setosa. C'est le premier objectif.
• D'un autre côté, le nœud du côté «False» se branche davantage sur True ou False en fonction de la nouvelle condition de classification ➁. De cette façon, nous descendrons la hiérarchie en ramifiant, en visant le but ** où la pureté de Gini est de 0,0.

Supplément

• Comme mentionné ci-dessus, puisqu'il est implémenté sur google colaboratory, procédez comme suit pour importer le dendrogramme sur le PC local.

#Exporter vers un fichier png
graph.write_png("iris.png ")

#Télécharger à partir de google colaboratory
from google.colab import files
files.download('iris.png')