[PYTHON] Comprendre l'arbre de décision et classer les documents

introduction

Cette fois, j'ai résumé l'arbre de décision de l'algorithme d'apprentissage automatique. Afin de comprendre le système de développement de l'arbre de décision tel que Random Forest et XGBoost, je voudrais bien comprendre les bases.

référence

Pour comprendre l'arbre de décision, je me suis référé à ce qui suit.

• Apprentissage automatique pratique avec scikit-learn et TensorFlow
• Faire et comprendre! Introduction à l'algorithme d'apprentissage d'ensemble

Arbre de décision

Aperçu de l'arbre de décision

** L'arbre de décision est un algorithme qui recherche la «feuille» qui correspond le mieux à la condition en traçant la branche selon la condition à partir de la «racine». ** Créez une expression conditionnelle composée de variables explicatives en tant que nœud basé sur les données d'apprentissage, et créez automatiquement un modèle qui peut dériver le résultat de la prédiction dans la partie "feuille". Il peut gérer à la fois les problèmes de classification et les problèmes de régression, et ils sont appelés respectivement ** arbres de régression ** et ** arbres de classification **.

Les avantages et les inconvénients sont les suivants, mais je pense que l'avantage de ** facile à interpréter ** est la raison pour laquelle on utilise le plus l'arbre de décision.

mérite

--Facile à interpréter (visualisez clairement ce qui est jugé comme une quantité de caractéristiques)

• Peut gérer les données de différentes échelles telles quelles (aucun prétraitement tel que la mise à l'échelle n'est requis)

Démérite

――Ce n'est pas une méthode avec des performances de classification élevées

• Sujet au surapprentissage
• Ne convient pas aux données linéaires

Image de l'arbre de décision

Entraînons facilement l'algorithme d'arbre décisif pour le jeu de données iris de sklearn et dessinons l'arbre décisif.

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier

iris = load_iris()

X = iris.data[:,2:]
y = iris.target

tree_clf = DecisionTreeClassifier(max_depth=2, random_state=42)
tree_clf.fit(X, y)

from graphviz import Source
from sklearn.tree import export_graphviz

export_graphviz(
        tree_clf,
        out_file=os.path.join("iris_tree.dot"),
        feature_names=iris.feature_names[2:],
        class_names=iris.target_names,
        rounded=True,
        filled=True
    )

Ce qui suit est exécuté sur la ligne de commande (pour convertir le fichier dot en png)

$ dot -Tpng iris_tree.dot -o iris_tree.png

Ensuite, l'arbre de décision suivant peut être généré. Il se branche selon que la condition est remplie (Vrai ou Faux), et les nœuds colorés sont utilisés comme «feuilles» pour dériver le résultat final de la prédiction.

Apprentissage et impureté des arbres de décision

Il y a ** impureté ** comme index pour voir si chaque nœud de l'arbre de décision est capable de créer une branche conditionnelle avec succès. De plus, il existe deux méthodes pour mesurer l '** impureté **: ** la pureté GINI ** et ** l'entropie **.

• Notez qu'il est complètement différent du coefficient de Gini, qui est souvent utilisé comme indice pour mesurer les inégalités de revenus.

Impuretés GINI

En supposant que $ n $ est le nombre de classes contenues dans les données et que $ p_ {i} $ est la probabilité que les données soient de la classe $ i $, l'impureté de Gini peut être exprimée par la formule suivante.

Gini(p) = \sum_{i=1}^{n} p_{i}(1-p_{i}) = 1-\sum_{i=1}^{n} p_{i}^2

Il est difficile de comprendre s'il ne s'agit que d'une formule, alors regardons un exemple concret. Encore une fois, vérifiez la partie noeud vert de l'arbre de décision illustré précédemment. La valeur de ** valeurs ** ici indique combien de données peuvent être classées dans chaque classe de cette branche conditionnelle, et la valeur de ** classe ** détermine cette classification au moment de cette branche conditionnelle. , Représente cela.

Si vous vérifiez les * valeurs * du nœud vert, il s'agit de [0, 49, 5], ce qui signifie que 0 donnée est définie sur Setosa, 49 données sont définies sur Versicle et 5 données sont définies sur Virginia dans cette branche conditionnelle. Cela signifie qu'il est classé dans. Cependant, puisque la valeur de * class * est versicle cette fois, il est préférable ** que tous soient classés comme versicle. En d'autres termes, tout ce qui est classé comme ** impuretés ** peut être qualifié de ** impuretés **, de sorte que l'arbre déterminant utilise un indice appelé ** impur ** pour le mesurer quantitativement.

Calculons l'impureté Gini de cet exemple spécifique.

1 - (\dfrac{49}{50})^2 - (\dfrac{5}{50})^2 \approx 0.168

J'ai pu calculer l'impureté de Gini. Vous pouvez voir qu'il correspond à la valeur de * gini * dans le nœud vert.

Entropie

Il est également possible d'utiliser entpy comme indicateur de pureté. L'entropie est un concept qui exprime le ** désordre ** basé sur l'idée de la théorie de l'information. L'image est que si l'entropie est grande, ** désordonné = haute pureté **. L'explication du concept d'entropie est donnée dans Article précédent, veuillez donc vous y référer également.

L'entropie est exprimée par la formule suivante.

H(p) = -\sum_{i=1}^{n} p_{i}log_{2}(p_{i})

Calculons l'enthousiasme du nœud vert comme dans le cas de Gini impur.

-(\dfrac{49}{50})log_{2}(\dfrac{49}{50}) - (\dfrac{5}{50})log_{2}(\dfrac{5}{50}) \approx 0.445

Même sur sklearn, en donnant critère = 'entropie' comme argument lors de l'entraînement d'un modèle, il est possible de procéder à l'entraînement avec l'impureté comme entropie. Dans l'arbre de décision ci-dessous, vous pouvez voir que * entropy * est inclus au lieu de * gini *.

• Puisque le calcul par défaut de sklearn est effectué avec la base du numéro de journal étant 2, la base du logarithme est également décrite comme 2. Il n'y a pas de problème si la base du logarithme est décrite par le nombre de Napiers.

En gros, il semble qu'il n'y ait pas de grande différence dans les résultats d'apprentissage entre l'utilisation de ** Gini Impure ** et ** Entropy **, mais l'utilisation de Gini Impure est légèrement meilleure. Il semble que la vitesse de calcul soit rapide.

Algorithme de formation CART

Il y a plusieurs algorithmes dans l'arbre de décision, mais cette fois je vais vous présenter le CART (Classification and Regression Tree) le plus basique. L'algorithme sklearn utilise CART. CART est un algorithme qui crée uniquement des branches conditionnelles à deux choix (Oui ou Non) sur chaque nœud, et crée des branches afin que la fonction de coût illustrée ci-dessous soit minimisée.

Considérez qu'une caractéristique est $ k $ et les données sont divisées en deux au seuil $ t_ {k} $ pour ce $ k $. A ce moment, l'optimum $ k $ et $ t_ {t} $ peut être obtenu en minimisant la fonction de perte suivante.

L(k, t_{t}) = \dfrac{n_{right}}{n}Gini_{right} + \dfrac{n_{left}}{n}Gini_{left}

• $ Gini_ {right} / Gini_ {right} $ sont chacun impurs après division gauche et droite
• $ n_ {right} / n_ {left} $ est le nombre de données après la division gauche et droite

La signification de la formule ci-dessus est la moyenne pondérée du nombre de données impures du nœud après la division gauche et droite, et vous pouvez trouver le seuil optimal en le minimisant.

• La description ci-dessus est basée sur l'hypothèse que l'indice de pureté de Gini est utilisé pour la pureté. L'entropie peut être utilisée.

Déterminer les paramètres de l'arbre

L'arbre de décision continuera à se ramifier profondément jusqu'à la ligne ** où la pureté ne diminue pas même si elle est davantage divisée. Cependant, étant donné que l'arbre de décision a la propriété de ** facilement surajustement aux données d'entraînement données **, lui permettre de créer des branches à n'importe quelle profondeur peut facilement provoquer un surentraînement.

En guise de contre-mesure, donnez des paramètres qui limitent la forme de l'arbre de décision. Des exemples typiques sont les paramètres qui limitent la profondeur de l'arbre ("max_depth" pour sklearn) et la limite inférieure du nombre d'échantillons requis pour diviser un nœud ("min_sample_leaf" pour sklearn).

Classification des documents à l'aide de l'arbre de décision

Création d'un modèle d'arbre de décision à l'aide de sklearn

Dans ce qui suit, nous allons en fait créer un modèle de l'arbre de décision à l'aide de la bibliothèque.

Bibliothèque utilisée

scikit-learn 0.21.3

base de données

Vous pouvez facilement créer un modèle d'arbre de décision à l'aide de sklearn. Cette fois, nous utiliserons le "corpus d'actualités de livingoor" pour l'ensemble de données. Pour plus de détails sur l'ensemble de données et la méthode d'analyse morphologique, veuillez consulter Publié dans l'article précédemment publié. Je vais.

Dans le cas du japonais, un prétraitement qui décompose les phrases en éléments morphologiques est nécessaire à l'avance, donc après avoir décomposé toutes les phrases en éléments morphologiques, elles sont déposées dans la trame de données suivante.

La colonne la plus à droite est l'analyse morphologique de toutes les phrases et séparées par des espaces de demi-largeur. Utilisez-le pour créer un modèle de l'arbre de décision.

Apprentissage de modèle

Créez un modèle de l'arbre de décision à l'aide de sklearn. Voici les principaux paramètres de création d'un modèle.

Cette fois, après avoir converti la phrase au format Sac de mots (en comptant le nombre de mots que chaque mot contient dans chaque phrase et en la vectorisant), le vecteur est appliqué à l'arbre de décision. J'essaierai de classer les articles liés à l'informatique appelés «piratage de la vie» et les articles liés au sport appelés «montre-sport».

import pandas as pd
import pickle

#On suppose que la trame de données après décomposition morphologique a déjà été décapée.
with open('df_wakati.pickle', 'rb') as f:
    df = pickle.load(f)

#Vérifiez si vous pouvez classer deux types d'articles cette fois
ddf = df[(df[1]=='sports-watch') | (df[1]=='it-life-hack')].reset_index(drop = True)

#Phrases de sac en utilisant la bibliothèque de sklearn-of-Convertir au format de mots
from sklearn.feature_extraction.text import CountVectorizer
vectorizer = CountVectorizer(token_pattern="(?u)\\b\\w+\\b")
X = vectorizer.fit_transform(ddf[3])

#Convertir le type d'article en valeur numérique
def convert(x):
    if x == 'it-life-hack':
        return 0
    elif x == 'sports-watch':
        return 1

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

iris = load_iris()

X = X
y = ddf[1].apply(lambda x : convert(x))

#Séparez les données d'entraînement et les données d'évaluation
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)

#Apprendre le modèle
tree_clf = DecisionTreeClassifier(criterion = 'gini', max_depth=4, min_samples_leaf = 10,random_state=42)
tree_clf.fit(X_train, y_train)

#Sortie du résultat pour les données d'évaluation
print(tree_clf.score(X_test, y_test))

La valeur sortie comme précision est ici. La précision est meilleure que vous ne pouvez l'imaginer. Il semble y avoir une nette différence entre les mots utilisés dans les articles liés à l'informatique et les articles liés au sport.

0.9529190207156308

Visualisons maintenant le modèle créé cette fois.

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

export_graphviz(
        tree_clf,
        out_file=os.path.join("text_classification.dot"),
        feature_names=vectorizer.get_feature_names(),
        class_names=['it-life-hack', 'sports-watch'],
        rounded=True,
        filled=True
    )

Ce qui suit est exécuté comme une commande

$ dot -Tpng text_classification.dot -o text_classification.png

Vous pouvez voir que des fonctionnalités convaincantes telles que "produit" et "joueur" sont adoptées comme conditions de division des nœuds. C'est un gros avantage que le contenu ne soit pas une boîte noire.

Next Je voudrais étudier pas à pas Random Forest, Adaboost, Xgboost, lightGBM, etc., qui sont les systèmes de développement de l'arbre de décision.