Einführung

In diesem Artikel werde ich den Random Forest-Algorithmus zusammenfassen.

Zufällige Gesamtstrukturen sind eine Kombination aus vielen Entscheidungsbäumen. Daher müssen Sie zuerst den Entscheidungsbaumalgorithmus verstehen.

Den Entscheidungsbaum finden Sie im Artikel hier.

Zufälliger Wald ist ein Teil des Ensemble-Lernens. Lassen Sie uns über das Lernen von Ensembles sprechen.

Was ist Ensemble-Lernen?

Ensemble-Lernen ist eine Technik, die versucht, bessere Vorhersagen zu erzielen, indem mehrere Lernmaschinen kombiniert werden.

In vielen Fällen erzielen Sie bessere Ergebnisse als bei Verwendung eines einzelnen Modells.

In Bezug auf die Kombination mehrerer Lernender wird im Fall der Klassifizierung die "Mehrheitsentscheidung" mehrerer Lernender getroffen, und im Fall der Regression wird der "Durchschnitt" mehrerer Lernender getroffen.

Häufig verwendete Techniken beim Lernen von Ensembles sind "Absacken", "Boosten", "Stapeln" und "Anstoßen".

Zufälliger Wald kann als Ensemble-Lernen bezeichnet werden, bei dem der "Entscheidungsbaum" als Lernender mit einer als Bagging bezeichneten Technik verwendet wird.

Es kamen viele Begriffe heraus und es wurde schwer zu verstehen. Ich werde jede Technik erklären.

Ich habe auf den Artikel [hier] verwiesen (https://mathwords.net/bagging).

Über das Absacken

Bagging ist eine Abkürzung für Bootstrap Aggregation.

Erstellen Sie mithilfe einer Technik namens Boost Trap mehrere Datensätze aus einem Datensatz, generieren Sie einen Lernenden für jeden duplizierten Datensatz und treffen Sie eine Mehrheitsentscheidung über die mehreren auf diese Weise erstellten Lernenden. Wenn Sie dies tun, wird die endgültige Vorhersage getroffen.

Boost Trap ist eine Methode zum Abtasten von n Daten aus einem Datensatz, die eine Duplizierung ermöglicht.

Der Datensatz sei $ S_0 = (d_1, d_2, d_3, d_4, d_5) $, und wenn n = 5 Datenstücke abgetastet werden, ist $ S_1 = (d_1, d_1, d_3, d_4, d_5) $ oder $ S_2 = Sie erstellen einen Datensatz wie (d_2, d_2, d_3, d_4, d_5) $.

Wie Sie sehen können, können Sie Boost-Traps verwenden, um viele verschiedene Datensätze aus einem Datensatz zu erstellen.

Betrachten wir den vorhergesagten Wert anhand eines konkreten Beispiels.

Generieren Sie aus dem Trainingsdatensatz N Boost-Trap-Datensätze der Größe n.

Erstellen Sie mit diesen Daten N Vorhersagemodelle und lassen Sie jeden Vorhersagewert $ y_n (X) $ sein.

Da der Durchschnitt dieser N vorhergesagten Werte der endgültige vorhergesagte Wert ist, ist der endgültige vorhergesagte Wert des Modells unter Verwendung des Absackens wie folgt.

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

Dies ist das Ende der Erklärung des Absackens. Als nächstes schauen wir uns das Boosten an.

Über das Boosten

Beim Boosten werden schwache Lernende nacheinander konstruiert, anstatt schwache Lernende unabhängig zu machen, wie beim Absacken. Zu diesem Zeitpunkt wird der k + 1. schwache Lernende basierend auf dem k-ten schwachen Lernenden konstruiert (um die Schwäche auszugleichen).

Im Gegensatz zum Absacken, bei dem schwache Lernende unabhängig voneinander generiert werden, dauert das Boosten, bei dem Sie nacheinander schwache Lernende generieren müssen, einige Zeit. Stattdessen ist das Boosten tendenziell genauer als das Absacken.

Stapeln

Für das Absacken haben wir einen einfachen Durchschnitt von N vorhergesagten Werten berücksichtigt.

Dieser Algorithmus wertet einzelne Vorhersagen gleichermaßen aus und berücksichtigt nicht die Bedeutung jedes Modells.

Durch das Stapeln werden einzelne vorhergesagte Werte entsprechend ihrer Wichtigkeit gewichtet, um den endgültigen vorhergesagten Wert zu erhalten.

Es wird durch die folgende Formel ausgedrückt.

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

Stoßen

Bumping ist eine Technik, um das am besten passende Modell unter mehreren Lernenden zu finden.

Generieren Sie N Modelle mit dem Boost-Trap-Datensatz, wenden Sie den damit erstellten Lernenden auf die Originaldaten an und wählen Sie das Modell mit dem kleinsten Vorhersagefehler als bestes Modell aus.

Dies mag als weniger vorteilhafte Methode erscheinen, vermeidet jedoch das Lernen mit Daten von schlechter Qualität.

Über den Random Forest-Algorithmus

Bisher haben wir uns mit dem Lernen von Ensembles befasst.

Random Forest ist eine Methode, die "Bagging" beim Lernen von Ensembles verwendet und auch "Entscheidungsbaum" als Basislerner verwendet.

Der Algorithmus sieht folgendermaßen aus:

Erstellen Sie aus den Trainingsdaten N Boost-Trap-Datensätze.
Verwenden Sie diesen Datensatz, um N Entscheidungsbäume zu generieren. Zu diesem Zeitpunkt werden m Merkmalsgrößen zufällig aus p Merkmalsgrößen ausgewählt.
Im Fall der Klassifizierung wird die Mehrheit der N Entscheidungsbäume verwendet, und im Fall der Regression ist der Durchschnitt der Vorhersagen von N Entscheidungsbäumen die endgültige Vorhersage.

Aufgrund von 2 gibt es einen Grund, nur einige Feature-Mengen zu verwenden.

Dies liegt daran, dass beim Lernen von Ensembles die Vorhersagen umso genauer sind, je geringer die Korrelation zwischen den Modellen ist.

Das Bild ist, dass es besser ist, Menschen mit unterschiedlichen Ideen zu haben, als viele ähnliche Menschen.

Mit der Boost-Falle wird das Training bereits mit unterschiedlichen Daten durchgeführt. Durch weitere Änderung der Merkmalsmenge kann jedoch ein Training mit weiteren unterschiedlichen Daten durchgeführt und die Korrelation des Modells verringert werden.

Zufällige Gesamtstrukturimplementierung

Jetzt implementieren wir es.

Lassen Sie uns diesmal die von make_moons in sklearn generierten Daten klassifizieren.

Zeichnen wir die Daten mit dem folgenden Code.

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 kann mit dem Argument (X-Koordinate, Y-Koordinate, korrekte Beschriftung) gezeichnet werden.

Zeichnen wir mit normal ax.plot anstelle von mglearn. Ich habe die Funktion wie folgt erstellt.

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 bedeutet einen blauen Kreis und r ^ bedeutet ein rotes Dreieck.

Lassen Sie uns diesen Teil zusammenfassen. Das erste gibt die Farbe an, und die Akronyme wie "rot", "blau", "grün" und "cyan" geben die Farbe an.

Der zweite Buchstabe gibt die Form an und '', 'x', 'o', '^' und 'v' sind Quadrate, Kreuze, Kreise, obere Dreiecke und untere Dreiecke in der Reihenfolge von links.

Wir werden die obigen Daten anhand einer zufälligen Gesamtstruktur klassifizieren.

Unten ist der 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()

Sie können sehen, dass es als ein ziemlich gutes Gefühl eingestuft wird.

Ich werde den Code erklären.

_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)

Ich erstelle einen Gitterpunkt mit diesem Code. Die Rasterpunkte finden Sie im Artikel hier.

Erstellen Sie Rasterpunkte mit Rändern, die über den Minimal- und Maximalwerten des Plotbereichs der Daten liegen.

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

Nach dem Konvertieren von 100 × 100-Daten in ein eindimensionales Array mit rabel () wird es in einen vertikalen 10000 × 1-Vektor mit Umformung (-1, 1) konvertiert und durch p.hstack horizontal verbunden.

y_pred = model.predict (X) .reshape (yy.shape) sagt das Modell für 10000 × 2 Daten voraus. Das Ergebnis ist 0 auf einer Seite des Modells und 1 auf der anderen Seite, daher konvertiere ich es zurück in 100x100-Daten.

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

Die Farbe beim Erstellen der Konturlinie wird durch custom_cmap angegeben, und die Konturlinie wird durch "ax.contourf (xx, yy, y_pred, alpha = 0,3, cmap = custom_cmap)" gezeichnet.

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)

Dieser Code klassifiziert die Daten, erstellt ein Modell für die zufällige Gesamtstruktur und trainiert sie dann. Lassen Sie uns nun das Vorhersagemodell mit dem folgenden Code bewerten.

print(random_clf.score(X_test, Y_test))

0.96

Am Ende

Das ist alles für diesen Artikel.

Vielen Dank für Ihre Beziehung.

[PYTHON] [Maschinelles Lernen] Fassen wir die zufällige Gesamtstruktur auf leicht verständliche Weise zusammen