introduction

Jusqu'à présent, nous avons résumé la régression logistique, les machines vectorielles de support, les réseaux de neurones, etc. Cette fois, je vais résumer les arbres de décision de base tels que XGBoost, LightGBM et Random Forest.

Qu'est-ce qu'un arbre de décision?

Un arbre de décision est un algorithme qui «sépare les données étape par étape et produit des résultats d'analyse en forme d'arbre».

Les avantages de réaliser une analyse avec cet arbre de décision sont:

Facile à comprendre (la base de classification peut être visualisée)
Applicable à la fois à la classification et à la régression
Peut gérer un large éventail de problèmes

Il existe des fonctionnalités telles que. En particulier, je pense que le premier avantage est grand. D'autres classificateurs (machines vectorielles de support, réseaux de neurones, etc.) sont très compliqués et encadrés dans les calculs effectués à l'intérieur, il est donc difficile pour quiconque est familier avec le contenu du modèle de comprendre le contenu. Il y a un visage. D'autre part, l'arbre de décision est une fonctionnalité facile à comprendre car les motifs de division sont clairs, comme le montre la figure ci-dessus. Je pense que cela ** facile à comprendre ** est un énorme avantage. C'est parce que je ne pense pas que ce soit une bonne attitude pour un technicien pour une personne qui utilise un modèle pour produire des résultats en utilisant quelque chose qu'il ne comprend pas **.

Cet arbre de décision est un algorithme qui peut être appliqué à la fois à la classification et à la régression, mais cette fois, je voudrais résumer la classification. De plus, l'arbre de décision a un algorithme appelé CART et C4.5. Cette fois, nous parlons de CART.

Comment décider des critères de division

Divisez de sorte que les éléments après division (données à diviser) soient pour chaque élément que vous voulez diviser (= la pureté après division est le minimum). L'impureté est un indicateur de la façon dont différentes classes d'éléments sont mélangées.

Je voudrais l'examiner brièvement avec un exemple. Je voudrais charger et créer la méthode make_blobs () de scikit learn qui me donne un échantillon de spray.

`RF.ipynb`


#Imports
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn

from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=500, centers=4,
                  random_state=8, cluster_std=2.2)

#Scatter plot the points
plt.figure(figsize=(10,10))
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='jet')

Le diagramme de dispersion original est ici.

Maintenant, réfléchissons à la façon de diviser ce diagramme de dispersion.

En raison de la ligne de séparation à gauche, l'élément $ [2], qui est l'opposé du groupe qui contient beaucoup d'élément $ [0], [1] $ (à l'inverse, ne contient pas $ [2], [3] $). Vous pouvez voir qu'il peut être divisé en groupes contenant beaucoup de [3] $ (à l'inverse, $ [0] et [1] $ ne sont pas inclus). Ce type de division est une méthode de division avec moins de pureté. Par contre, dans le cas de la ligne de division à droite, vous pouvez voir que les éléments de $ [0] à [3] $ sont mélangés dans le groupe après division. C'est ce qu'on appelle avoir beaucoup d'impuretés. Trouvez la ligne de division comme indiqué sur la gauche et classez-la plusieurs fois (= appelée la profondeur de l'arbre de décision) pour classer l'objectif.

Comment trouver la pureté

Maintenant, résumons comment exprimer cette impureté. Cette fois, nous nous concentrerons sur l'indice de diversité de Gini $. La traduction littérale est l'indice de diversité de Gini. Je pense que vous pouvez comprendre le sens en japonais, mais il semble que cela soit souvent appelé impur.

Considérons une hiérarchie (= nœud) $ t $ avec un arbre de décision. Un nœud est un groupe après avoir été divisé. Considérons ensuite le cas où il y a des échantillons $ n $ dans le nœud et des classes $ c $ dans le nœud. A ce moment, en supposant que le nombre d'échantillons appartenant à la classe $ i $ dans le nœud $ t $ est $ n_i $, le rapport des échantillons appartenant à la classe $ i $ $ p (i | t) $ peut être exprimé comme suit. Je peux le faire.

p(i|t) = \frac{n_i}{n} \tag{1}

A ce moment, Gini Impure $ I_G (t) $ peut être exprimé comme suit. $ I_G(t) = 1 - \sum_{i=1}^c {p(i|t)}^2 \tag{2} $

La somme de $ p (i | t) ^ 2 $ augmentera si une bonne division est faite. Par conséquent, $ I_G (t) $ devient plus petit. Nous ferons un bon classificateur en utilisant cet indice d'évaluation.

Conçu pour rendre le graphique plus facile à voir

Colorez chaque classe pour la rendre plus facile à comprendre.

`RF.ipynb`


def visualize_tree(classifier, X, y, boundaries=True,xlim=None, ylim=None):
    '''
Visualisez l'arbre de décision.
    INPUTS:Modèle de classification, X, y, optional x/y limits.
    OUTPUTS:Visualisation des arbres de décision à l'aide de Meshgrid
    '''
    #Construire un modèle à l'aide de l'ajustement
    classifier.fit(X, y)
    
    #Réglage automatique de l'axe
    if xlim is None:
        xlim = (X[:, 0].min() - 0.1, X[:, 0].max() + 0.1)
    if ylim is None:
        ylim = (X[:, 1].min() - 0.1, X[:, 1].max() + 0.1)

    x_min, x_max = xlim
    y_min, y_max = ylim
    
    
    #Créez une grille maillée.
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
                         np.linspace(y_min, y_max, 100))
    
    #Enregistrer les prédictions du classificateur sous Z
    Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])

    #Utilisez meshgrid pour le façonner.
    Z = Z.reshape(xx.shape)
    
    #Colorez chaque catégorie.
    plt.figure(figsize=(10,10))
    plt.pcolormesh(xx, yy, Z, alpha=0.2, cmap='jet')
    
    #Il tire également des données d'entraînement.
    plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='jet')
    
    plt.xlim(x_min, x_max)
    plt.ylim(y_min, y_max)        
    
    def plot_boundaries(i, xlim, ylim):
        '''
Dessinez une bordure.
        '''
        if i < 0:
            return

        tree = classifier.tree_
        
        #Appelez récursivement pour tracer les limites.
        if tree.feature[i] == 0:
            plt.plot([tree.threshold[i], tree.threshold[i]], ylim, '-k')
            plot_boundaries(tree.children_left[i],
                            [xlim[0], tree.threshold[i]], ylim)
            plot_boundaries(tree.children_right[i],
                            [tree.threshold[i], xlim[1]], ylim)
        
        elif tree.feature[i] == 1:
            plt.plot(xlim, [tree.threshold[i], tree.threshold[i]], '-k')
            plot_boundaries(tree.children_left[i], xlim,
                            [ylim[0], tree.threshold[i]])
            plot_boundaries(tree.children_right[i], xlim,
                            [tree.threshold[i], ylim[1]])
    
    if boundaries:
        plot_boundaries(0, plt.xlim(), plt.ylim())

Essayez de classer par arbre de décision

`RF.ipynb`


from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(criterion='entropy',max_depth=2,random_state=0)

visualize_tree(clf,X,y)

J'ai pu le diviser en un bon sentiment. Dans ce qui précède, déterminez la profondeur de l'arbre déterminé avec max_depth. Augmenter (= approfondir) la valeur de cette max_depth entraînera un surapprentissage. Essayez-le avec max_depth = 6.

Vous pouvez voir qu'il est sur-divisé (en particulier la classe rouge). Le fait est que vous devez ajuster vous-même cette profondeur.

Visualisation de la base de l'arbre de décision

À propos, l'image de l'arbre de décision lorsqu'elle est vérifiée à la profondeur 2 est présentée ci-dessous.

Les valeurs numériques et l'impureté de Gini qui servent de critères de classification sont listées. valeur est le nombre d'éléments dans les classes [0] à [3].

Comment générer une image d'arbre de décision

Au fait, c'est une image rapide, mais il faut importer la librairie et installer le logiciel.

Installez pydotplus
Installez graphviz
À travers le chemin

Les trois actions ci-dessus étaient nécessaires pour que je sauve.

Installez pydotplus

Il s'agit d'une bibliothèque qui enregistre le contenu divisé par l'arbre de décision dans un fichier .dot.

`console`


pip install pydotplus

Comme toute autre bibliothèque, vous pouvez l'installer avec pip.

Installez graphviz

J'ai téléchargé le programme d'installation (graphviz-2.38.msi) à partir de cette URL.

https://graphviz.gitlab.io/_pages/Download/Download_windows.html

Lorsque le téléchargement est terminé, double-cliquez sur "graphviz-2.38.msi" pour l'installer. De plus, installez graph viz sur pip.

passer le chemin

Ensuite, passez path pour le rendre pdf. Spécifiez le dossier où se trouve «dot.exe». J'ai déjà résumé la méthode, veuillez donc vous référer ici.

https://qiita.com/Fumio-eisan/items/340de9fe220a90607013

Enfin, vous devez réécrire la syntaxe dans graphviz.py comme suit:

À ce stade, l'arbre de décision peut être converti en .dot et pdf ci-dessous.

`RF.ipynb`



import pydotplus
import os
from graphviz import Source
from sklearn.tree import export_graphviz

export_graphviz(
        clf,
        out_file=os.path.join("text_classification.dot"),
        class_names=['1', '2','3','4'],
        rounded=True,
        filled=True
    )
with open("random.dot", 'w') as f:
    f = export_graphviz(clf, out_file=f)

data = export_graphviz(clf, out_file=None)
graph = pydotplus.graph_from_dot_data(data)
graph.write_pdf("random.pdf")

J'ai fait référence à ce site.

Gestion des erreurs GraphViz (exécutables GraphViz introuvables) https://niwakomablog.com/graphviz-error-handling/

À la fin

Cette fois, nous avons résumé le contenu et la mise en œuvre de la classification des arbres de décision. L'idée est facile à comprendre et à mettre en œuvre. Cependant, à la fin, j'ai senti qu'il y avait un léger obstacle à transformer l'arbre de décision en pdf. Ensuite, je voudrais faire un retour.

Le programme complet est ici. https://github.com/Fumio-eisan/RF_20200423

[PYTHON] J'ai essayé de comprendre l'arbre de décision (CART) pour classer soigneusement

introduction

Qu'est-ce qu'un arbre de décision?

Comment décider des critères de division

RF.ipynb

Comment trouver la pureté

Conçu pour rendre le graphique plus facile à voir

RF.ipynb

Essayez de classer par arbre de décision

RF.ipynb

Visualisation de la base de l'arbre de décision

Comment générer une image d'arbre de décision

console

RF.ipynb

À la fin

`RF.ipynb`

`RF.ipynb`

`RF.ipynb`

`console`

`RF.ipynb`