[PYTHON] [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:
-
Créez N ensembles de données d'interruption de boost à partir des données d'entraînement.
-
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.
-
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()
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()
«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()
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