Arbre de décision et forêt aléatoire

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

Méthode de calcul de la probabilité d'appartenance à la variable objective en combinant plusieurs variables explicatives. L'image ci-dessous calcule la probabilité en fonction de son appartenance à des conditions telles que Oui / Non.

スクリーンショット 2016-05-05 16.43.44.png

Qu'est-ce que Random Forest?

Random Forest est l'une des méthodes d'apprentissage d'ensemble (classificateurs composés en collectant plusieurs classificateurs). Étant donné que plusieurs arbres de décision sont collectés et utilisés, les arbres sont collectés et utilisés comme forêt.

Essayez-le (arbre de décision dans sklearn)

Données prêtes

Préparez des données créées au hasard.

{get_dummy_dataset.py}


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

from sklearn.datasets import make_blobs #Pour générer des données factices
X, y = make_blobs(n_samples=500, centers=4, random_state=8, cluster_std=2.4)
# n_samples:Nombre de centres d'échantillonnage:Nombre de points centraux aléatoire_state:cluster de valeurs de départ_std:Degré de variation

Aperçu des données

{display_dummy_dataset.py}


plt.figure(figsize =(10,10))
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='jet')
スクリーンショット 2016-05-05 17.20.23.png

La distribution de 500 données générées à partir des quatre points centraux ressemble à ceci.

Essayez l'arbre de décision

Le code de visualize_tree est écrit en bas.

{do_decision_tree.py}


from sklearn.tree import DecisionTreeClassifier             #Pour l'arbre de décision
clf = DecisionTreeClassifier(max_depth=2, random_state = 0) #Création d'instance max_depth:Profondeur de l'arbre
visualize_tree(clf, X, y)    #Exécution de dessin
スクリーンショット 2016-05-05 17.24.32.png

Vous pouvez voir comment il peut être classé en quatre en utilisant des lignes droites. La précision change en fonction du nombre de profondeurs (max_depth) de l'arbre de décision, donc quand j'ai mis max_depth à 4, c'est devenu comme suit.

スクリーンショット 2016-05-05 17.26.17.png

De la profondeur 2, vous pouvez voir que vous essayez de faire une classification plus fine.

Cependant, plus la profondeur est élevée, plus la précision des données d'entraînement est élevée, mais plus il est facile de surapprendre. Pour éviter cela, essayez d'exécuter une forêt aléatoire.

Essayez une forêt aléatoire

{do_random_forest.py}


from sklearn.ensemble import RandomForestClassifier #Pour la forêt aléatoire
clf = RandomForestClassifier(n_estimators=100, random_state=0) #Création d'instance n_estimators:Spécifier le nombre d'arbres de décision à faire
visualize_tree(clf, X, y, boundaries=False)
スクリーンショット 2016-05-05 17.30.03.png

On peut voir que la classification n'est pas une simple ligne droite, mais elle semble être plus précise qu'un arbre de décision. Soit dit en passant, cela n'empêche pas toujours le surapprentissage: par exemple, le cercle rouge en bas à droite de la figure ci-dessus semble être hors de valeur, mais il est groupé en rouge.

Une fonction qui visualise le résultat.

{visualize_tree.py}


#Essayez de dessiner un arbre de décision
def visualize_tree(classifier, X, y, boundaries=True,xlim=None, ylim=None):
    """Fonction de visualisation de 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))
    
    #Effectuer des prédictions de classificateur
    Z = classifier.predict(np.c_[xx.ravel(), yy.ravel()])

    #Façonné à l'aide de meshgrid.
    Z = Z.reshape(xx.shape)
    
    #Coloré par classification.
    plt.figure(figsize=(10,10))
    plt.pcolormesh(xx, yy, Z, alpha=0.2, cmap='jet')
    
    #Dessiner 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 une régression dans une forêt aléatoire

Les forêts aléatoires peuvent également revenir.

Utilisez sin pour préparer des données qui font bouger les petites vagues en grandes vagues

{get_dummy_malti_sin_dataset.py}


from sklearn.ensemble import RandomForestRegressor

x = 10 * np.random.rand(100)

def sin_model(x, sigma=0.2):
    """Données factices constituées de grosses vagues + petites vagues + bruit."""
    noise = sigma * np.random.randn(len(x))

    return np.sin(5 * x) + np.sin(0.5 * x) + noise

#Calculer y à partir de x
y = sin_model(x)

#Essayez Plot.
plt.figure(figsize=(16,8))
plt.errorbar(x, y, 0.1, fmt='o')
スクリーンショット 2016-05-05 17.44.22.png

Données factices ondulées. Il diminue petit à petit.

Courir avec sklearn

{do_random_forest_regression.py}


from sklearn.ensemble import RandomForestRegressor #Pour la régression forestière aléatoire

#Préparez 1000 données de 0 à 10 pour confirmation
xfit = np.linspace(0, 10, 1000)       #1000 pièces de 0 à 10

#Exécution aléatoire de la forêt
rfr = RandomForestRegressor(100)  #Génération d'instance Spécifiez le nombre d'arbres à 100
rfr.fit(x[:, None], y)            #Exécution de l'apprentissage
yfit = rfr.predict(xfit[:, None]) #Exécution prédictive

#Obtenez la valeur réelle pour la comparaison des résultats.
ytrue = sin_model(xfit,0) #Envoyez xfit à la fonction de génération d'onde et obtenez le résultat

#Vérifiez le résultat
plt.figure(figsize = (16,8))
plt.errorbar(x, y, 0.1, fmt='o')
plt.plot(xfit, yfit, '-r')                #Tracé prédit
plt.plot(xfit, ytrue, '-k', alpha = 0.5)  #Diagramme de réponse correct
スクリーンショット 2016-05-05 17.53.01.png

Vous pouvez voir que la ligne rouge est la ligne de régression de la prédiction, et le résultat semble être raisonnablement bon.

Recommended Posts

Arbre de décision et forêt aléatoire
Forêt aléatoire (2)
Forêt aléatoire
Forêt aléatoire (classification) et réglage des hyperparamètres
Décision Scikit-learn Générer du code Python à partir de règles d'arbre / forêt aléatoire
Arbre de décision (load_iris)
Arbre de décision (classification)
Comprendre l'arbre de décision et classer les documents
Forêt aléatoire équilibrée en python
J'ai essayé d'utiliser RandomForest
[Apprentissage automatique] Comprendre la forêt aléatoire
Utiliser Random Forest avec Python
Qu'est-ce qu'un arbre de décision?
[Python] Tutoriel personnel sur l'arbre de décision
Apprentissage automatique: forêt supervisée - aléatoire
Machine Learning: Supervisé - Arbre de décision
Apprenez les catégories de texte japonais avec TF-IDF et Random Forest ~ Liveoor News
Arbre de décision (pour les débutants) -Édition de code-
Créer un arbre déterminé avec scikit-learn
Comparaison de la taille de la forêt aléatoire / du temps de traitement
Apprentissage automatique ③ Résumé de l'arbre de décision
Génération de nombres pseudo aléatoires et échantillonnage aléatoire
Différence entre le randint de Numpy et le randint de Random
Comparaison des modèles de régression - ARMA vs Random Forest Regression
[Apprentissage automatique] Essayez d'étudier une forêt aléatoire
2.Faites un arbre de décision à partir de 0 avec Python et comprenez-le (2. Bases du programme Python)
(Kaggle) Prédiction des survivants du Titanic à l'aide d'un modèle utilisant des arbres de décision et des forêts aléatoires
J'ai essayé de visualiser tous les arbres de décision de la forêt aléatoire avec SVG
Créez un arbre de décision à partir de 0 avec Python et comprenez-le (4. Structure des données)
Créez un arbre de décision à partir de 0 avec Python et comprenez-le (5. Entropie des informations)