[Apprentissage automatique] Résumons la forêt aléatoire de manière simple à comprendre

introduction

Dans cet article, je vais résumer l'algorithme de forêt aléatoire.

Les forêts aléatoires sont une combinaison de nombreux arbres de décision, vous devez donc d'abord comprendre l'algorithme d'arbre de décision.

Veuillez vous référer à l'article ici pour l'arbre de décision.

La forêt aléatoire fait partie de l'apprentissage d'ensemble. Parlons de l'apprentissage d'ensemble.

Qu'est-ce que l'apprentissage d'ensemble?

L'apprentissage d'ensemble est une technique qui tente d'obtenir de meilleures prédictions en combinant plusieurs machines d'apprentissage.

Dans de nombreux cas, vous obtiendrez de meilleurs résultats que d'utiliser un seul modèle.

Quant à la manière de combiner plusieurs apprenants, dans le cas de la classification, la «décision majoritaire» de plusieurs apprenants est prise, et dans le cas de la régression, la «moyenne» de plusieurs apprenants est prise.

Les techniques couramment utilisées dans l'apprentissage d'ensemble comprennent le «ensachage», le «renforcement», «l'empilement» et le «bumping».

On peut dire que la forêt aléatoire est un apprentissage d'ensemble utilisant un "arbre de décision" en tant qu'apprenant utilisant une technique appelée ensachage.

Beaucoup de termes sont sortis et c'est devenu difficile à comprendre. J'expliquerai chaque technique.

J'ai fait référence à l'article ici.

À propos de l'ensachage

Bagging est une abréviation pour l'agrégation bootstrap.

À l'aide d'une technique appelée boost trap, créez plusieurs ensembles de données à partir d'un ensemble de données, générez un apprenant pour chaque ensemble de données dupliqué et prenez une décision majoritaire sur les multiples apprenants créés de cette manière. Cela fera la prédiction finale.

Boost trap est une méthode d'échantillonnage de n données à partir d'un ensemble de données, permettant la duplication.

Soit l'ensemble de données $ S_0 = (d_1, d_2, d_3, d_4, d_5) $, et lors de l'échantillonnage n = 5 données, $ S_1 = (d_1, d_1, d_3, d_4, d_5) $ ou $ S_2 = Vous allez créer un ensemble de données tel que (d_2, d_2, d_3, d_4, d_5) $.

Comme vous pouvez le voir, vous pouvez utiliser des traps de boost pour créer de nombreux ensembles de données différents à partir d'un ensemble de données.

Considérons la valeur prédite avec un exemple concret.

Générez N ensembles de données d'interruption d'amplification de taille n à partir de l'ensemble de données d'entraînement.

Créez N modèles de prédiction à l'aide de ces données et laissez chaque valeur de prédiction être $ y_n (X) $.

Puisque la moyenne de ces N valeurs prédites est la valeur prédite finale, la valeur prédite finale du modèle utilisant l'ensachage est la suivante.

y(X) = \frac{1}{N}\sum_{n=1}^{N}y_n(X)

C'est la fin de l'explication de l'ensachage. Ensuite, regardons la stimulation.

À propos du boosting

En boostant, les apprenants faibles sont construits un par un dans l'ordre, au lieu de faire des apprenants faibles de manière indépendante comme dans le bagage. À ce moment-là, le k + 1e apprenant faible est construit sur la base du ke apprenant faible (pour compenser la faiblesse).

Contrairement à l'ensachage, qui génère indépendamment des apprenants faibles, le renforcement, qui vous oblige à générer des apprenants faibles un par un, prend du temps. Au lieu de cela, le boost a tendance à être plus précis que l'ensachage.

Empilement

Pour l'ensachage, nous avons considéré une simple moyenne de N valeurs prédites.

Cet algorithme évalue également les prédictions individuelles et ne prend pas en compte l'importance de chaque modèle.

L'empilement ajoute des poids aux valeurs prédites individuelles en fonction de leur importance pour obtenir la valeur prédite finale.

Il est exprimé par la formule suivante.

y(X) = \sum_{n=1}^{N}W_ny_n(X)

Cogner

Le bumping est une technique pour trouver le meilleur modèle d'ajustement parmi plusieurs apprenants.

Générez N modèles à l'aide de l'ensemble de données d'interruption d'amplification, appliquez l'apprenant créé à l'aide de celui-ci aux données d'origine et sélectionnez celui avec la plus petite erreur de prédiction comme meilleur modèle.

Cela peut sembler une méthode moins bénéfique, mais cela évite d'apprendre avec des données de mauvaise qualité.

À propos de l'algorithme de forêt aléatoire

Jusqu'à présent, nous avons traité de l'apprentissage d'ensemble.

Random Forest est une méthode qui utilise le «bagging» dans l'apprentissage d'ensemble et utilise également «l'arbre de décision» comme apprenant de base.

L'algorithme ressemble à ceci:

  1. Créez N ensembles de données d'interruption de boost à partir des données d'entraînement.

  2. Utilisez cet ensemble de données pour générer N arbres de décision. À ce stade, m quantités d'entités sont sélectionnées au hasard parmi p quantités d'entités.

  3. Dans le cas de la classification, la majorité des N arbres de décision est utilisée, et dans le cas de la régression, la moyenne des prédictions de N arbres de décision est la prédiction finale.

En raison de 2, il y a une raison d'utiliser uniquement certaines quantités de fonctionnalités.

En effet, dans l'apprentissage d'ensemble, plus la corrélation entre les modèles est faible, plus les prédictions sont précises.

L'image est qu'il vaut mieux avoir des gens avec des idées différentes que d'avoir beaucoup de gens similaires.

Avec le trap trap, l'apprentissage est déjà effectué avec des données différentes, mais en modifiant davantage la quantité de caractéristiques, un apprentissage avec d'autres données différentes peut être effectué et la corrélation du modèle peut être réduite.

Implémentation de forêt aléatoire

Maintenant, implémentons-le.

Cette fois, classons les données générées par make_moons dans sklearn.

Dessinons les données avec le code suivant.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from matplotlib.colors import ListedColormap
import mglearn

moons = make_moons(n_samples=200, noise=0.2, random_state=0)
X = moons[0]
Y = moons[1]
mglearn.discrete_scatter(X[:, 0], X[:, 1], Y)
plt.show()

image.png

mglearn.discrete_scatter peut être dessiné en prenant l'argument (coordonnée X, coordonnée Y, étiquette correcte).

Dessinons en utilisant ax.plot normal au lieu de mglearn. J'ai créé la fonction comme suit.

def plot_datasets(x, y):
    figure = plt.figure(figsize=(12, 8))
    ax = figure.add_subplot(111)
    ax.plot(x[:, 0][y == 0], x[:, 1][y == 0], 'bo', ms=15)
    ax.plot(x[:, 0][y == 1], x[:, 1][y == 1], 'r^', ms=15)
    ax.set_xlabel('$x_0$', fontsize=15)
    ax.set_ylabel('$x_1$', fontsize=15)


plot_datasets(X, Y)
plt.show()

image.png

«bo» signifie un cercle bleu et «r ^» signifie un triangle rouge.

Résumons cette partie. Le premier indique la couleur et les acronymes tels que «rouge», «bleu», «vert» et «cyan» indiquent la couleur.

La deuxième lettre indique la forme, et les ',' x ',' o ',' ^ 'et' v 'sont des carrés, des croix, des cercles, des triangles supérieurs et des triangles inférieurs dans l'ordre à partir de la gauche.

Nous classerons les données ci-dessus en utilisant une forêt aléatoire.

Ci-dessous le code.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier


def plot_dexision_boundary(model, x, y, ax, margin=0.3):
    _x = np.linspace(x[:, 0].min() - margin, x[:, 0].max() + margin, 100)
    _y = np.linspace(x[:, 1].min() - margin, x[:, 1].max() + margin, 100)
    xx, yy = np.meshgrid(_x, _y)
    X = np.hstack((xx.ravel().reshape(-1, 1), yy.ravel().reshape(-1, 1)))
    y_pred = model.predict(X).reshape(yy.shape)
    custom_cmap = ListedColormap(['green', 'cyan'])
    ax.contourf(xx, yy, y_pred, alpha=0.3, cmap=custom_cmap)


def plot_datasets(x, y, ax):
    ax = figure.add_subplot(111)
    ax.plot(x[:, 0][y == 0], x[:, 1][y == 0], 'gs', ms=15)
    ax.plot(x[:, 0][y == 1], x[:, 1][y == 1], 'c^', ms=15)
    ax.set_xlabel('$x_0$', fontsize=15)
    ax.set_ylabel('$x_1$', fontsize=15)


moons = make_moons(n_samples=200, noise=0.2, random_state=0)
X = moons[0]
Y = moons[1]

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, random_state=0)
random_clf = RandomForestClassifier()
random_clf.fit(X_train, Y_train)
figure = plt.figure(figsize=(12, 8))
ax = figure.add_subplot(111)
plot_datasets(X, Y, ax)
plot_dexision_boundary(random_clf, X, Y, ax)
plt.show()

image.png

Vous pouvez voir que c'est classé comme un très bon sentiment.

Je vais expliquer le code.

_x = np.linspace(x[:, 0].min() - margin, x[:, 0].max() + margin, 100)
_y = np.linspace(x[:, 1].min() - margin, x[:, 1].max() + margin, 100)
xx, yy = np.meshgrid(_x, _y)

Je crée un point de grille avec ce code. Veuillez vous référer à l'article ici pour les points de grille.

Créez des points de grille avec des marges supérieures aux valeurs minimale et maximale de la plage de tracé des données.

X = np.hstack((xx.ravel().reshape(-1, 1), yy.ravel().reshape(-1, 1)))
y_pred = model.predict(X).reshape(yy.shape)

Après avoir converti des données 100 × 100 en un tableau unidimensionnel avec rabel (), il est converti en un vecteur vertical de 10000 × 1 avec remodelage (-1, 1), et il est connecté horizontalement par p.hstack.

y_pred = model.predict (X) .reshape (yy.shape) prédit le modèle pour les données 10000 × 2. Le résultat est 0 d'un côté du modèle et 1 de l'autre, donc je le reconvertis en données 100x100.

custom_cmap = ListedColormap(['green', 'cyan'])
ax.contourf(xx, yy, y_pred, alpha=0.3, cmap=custom_cmap)

La couleur lors de la création de la ligne de contour est spécifiée par custom_cmap, et la ligne de contour est dessinée par ʻax.contourf (xx, yy, y_pred, alpha = 0.3, cmap = custom_cmap) `.

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, random_state=0)
random_clf = RandomForestClassifier()
random_clf.fit(X_train, Y_train)

Ce code classe les données, crée un modèle pour la forêt aléatoire, puis l'entraîne. Évaluons maintenant le modèle de prédiction avec le code suivant.

print(random_clf.score(X_test, Y_test))

0.96

À la fin

C'est tout pour cet article.

Merci pour votre relation.

Recommended Posts

[Apprentissage automatique] Résumons la forêt aléatoire de manière simple à comprendre
[Apprentissage automatique] Comprendre la forêt aléatoire
Apprentissage automatique: forêt supervisée - aléatoire
[Apprentissage automatique] Essayez d'étudier une forêt aléatoire
Recherche de semences aléatoires dans l'apprentissage automatique
J'ai essayé de comprendre l'apprentissage supervisé de l'apprentissage automatique d'une manière facile à comprendre, même pour les ingénieurs serveurs 1
J'ai essayé de comprendre l'apprentissage supervisé de l'apprentissage automatique d'une manière facile à comprendre, même pour les ingénieurs serveurs 2
[Python] J'ai essayé de résumer le type collectif (ensemble) d'une manière facile à comprendre.
J'ai essayé de résumer Cpaw Level1 & Level2 Write Up d'une manière facile à comprendre
Affichez les journaux d'une manière facile à comprendre avec Ansible
Créez un environnement interactif pour l'apprentissage automatique avec Python
Forêt aléatoire équilibrée en python
Apprentissage automatique dans Delemas (s'entraîner)
Une introduction à l'apprentissage automatique
[Pour les débutants] Je souhaite expliquer le nombre d’apprentissage d’une manière facile à comprendre.
[Deep Learning from scratch] J'ai essayé d'expliquer la confirmation du gradient d'une manière facile à comprendre.
Utiliser Random Forest avec Python
Utilisé en EDA pour l'apprentissage automatique
Vérifiez si le fichier de paramètres est lu de manière simple à comprendre
Je vais vous expliquer comment utiliser Pandas d'une manière facile à comprendre.
Apprenez le machine learning à tout moment et en tout lieu dans l'environnement Jupyter Notebook à la demande
Automatisez les tâches de routine dans l'apprentissage automatique
Classification et régression dans l'apprentissage automatique
Apprentissage automatique dans Delemas (acquisition de données)
Python: prétraitement dans l'apprentissage automatique: présentation
Prétraitement dans l'apprentissage automatique 2 Acquisition de données
Prétraitement dans l'apprentissage automatique 4 Conversion de données
Vous serez ingénieur dans 100 jours ――Jour 81 ――Programmation ――À propos de l'apprentissage automatique 6
Vous serez ingénieur dans 100 jours ――Jour 82 ――Programmation ――À propos de l'apprentissage automatique 7
Vous serez ingénieur dans 100 jours ――Jour 79 ――Programmation ――À propos de l'apprentissage automatique 4
Comparer la grammaire de base de Python et Go d'une manière facile à comprendre
Vous serez ingénieur dans 100 jours ――Jour 76 ――Programmation ――À propos de l'apprentissage automatique
Vous serez ingénieur dans 100 jours ―― Jour 80 ―― Programmation ―― À propos de l'apprentissage automatique 5
Vous serez ingénieur dans 100 jours ――Jour 78 ――Programmation ――À propos de l'apprentissage automatique 3
Vous serez ingénieur dans 100 jours ――Jour 84 ――Programmation ――À propos de l'apprentissage automatique 9
Vous serez ingénieur dans 100 jours ――Jour 83 ――Programmation ――À propos de l'apprentissage automatique 8
Vous serez ingénieur dans 100 jours ――Jour 77 ――Programmation ――À propos de l'apprentissage automatique 2
Vous serez ingénieur dans 100 jours ――Jour 85 ――Programmation ――À propos de l'apprentissage automatique 10
[python] Techniques souvent utilisées dans l'apprentissage automatique
Une introduction à OpenCV pour l'apprentissage automatique
Python: prétraitement en machine learning: acquisition de données
[Python] Lorsqu'un amateur commence l'apprentissage automatique
Une introduction à Python pour l'apprentissage automatique
Classification des maladies par Random Forest en utilisant Python
[Python] Enregistrement des résultats d'apprentissage (modèles) dans l'apprentissage automatique
Python: prétraitement dans l'apprentissage automatique: conversion de données
Prétraitement dans l'apprentissage automatique 1 Processus d'analyse des données