Random Forest ist ein beliebter Algorithmus für maschinelles Lernen, der zur Technik des überwachten Lernens gehört. Es kann sowohl für Klassifizierungs- als auch für Regressionsprobleme in ML verwendet werden. Es basiert auf dem Konzept von Ensemblelernen, Das ist ein Prozess von Kombinieren mehrerer Klassifikatoren, um ein komplexes Problem zu lösen und die Leistung des Modells zu verbessern.
Wie der Name schon sagt, „Random Forest ist ein Klassifikator, der eine Reihe von Entscheidungsbäumen für verschiedene Teilmengen des gegebenen Datensatzes enthält und den Durchschnitt bildet, um die Vorhersagegenauigkeit dieses Datensatzes zu verbessern.“ Anstatt sich auf einen Entscheidungsbaum zu verlassen, übernimmt die Zufallsstruktur die Vorhersage von jedem Baum und basierend auf den Mehrheitsstimmen der Vorhersagen und sagt die endgültige Ausgabe voraus.
Die größere Anzahl an Bäumen im Wald führt zu einer höheren Genauigkeit und verhindert das Problem der Überanpassung.
Scanner scannen Java
Das folgende Diagramm erklärt die Funktionsweise des Random Forest-Algorithmus:
Hinweis: Um den Random Forest-Algorithmus besser zu verstehen, sollten Sie über Kenntnisse des Entscheidungsbaum-Algorithmus verfügen.
Annahmen für Random Forest
Da die Zufallsstruktur mehrere Bäume kombiniert, um die Klasse des Datensatzes vorherzusagen, ist es möglich, dass einige Entscheidungsbäume die korrekte Ausgabe vorhersagen, andere jedoch nicht. Aber alle Bäume zusammen sagen die korrekte Ausgabe voraus. Daher sind im Folgenden zwei Annahmen für einen besseren Random-Forest-Klassifikator aufgeführt:
- Die Merkmalsvariable des Datensatzes sollte einige tatsächliche Werte enthalten, damit der Klassifikator genaue Ergebnisse vorhersagen kann und nicht nur ein erratenes Ergebnis.
- Die Vorhersagen jedes Baums müssen sehr geringe Korrelationen aufweisen.
Warum Random Forest verwenden?
Im Folgenden sind einige Punkte aufgeführt, die erklären, warum wir den Random Forest-Algorithmus verwenden sollten:
- Im Vergleich zu anderen Algorithmen ist die Trainingszeit kürzer.
- Es prognostiziert die Ausgabe mit hoher Genauigkeit, selbst für den großen Datensatz, den es effizient verarbeitet.
- Es kann auch die Genauigkeit aufrechterhalten, wenn ein großer Teil der Daten fehlt.
Wie funktioniert der Random Forest-Algorithmus?
Random Forest funktioniert in zwei Phasen: Erstens wird durch die Kombination von N Entscheidungsbäumen ein Zufallswald erstellt, und zweitens werden Vorhersagen für jeden in der ersten Phase erstellten Baum getroffen.
Der Arbeitsprozess kann in den folgenden Schritten und Diagrammen erklärt werden:
Schritt 1: Wählen Sie zufällige K Datenpunkte aus dem Trainingssatz aus.
Schritt 2: Erstellen Sie die Entscheidungsbäume, die den ausgewählten Datenpunkten (Teilmengen) zugeordnet sind.
Schritt 3: Wählen Sie die Zahl N für Entscheidungsbäume, die Sie erstellen möchten.
Schritt 4: Wiederholen Sie Schritt 1 und 2.
Schritt 5: Suchen Sie für neue Datenpunkte die Vorhersagen jedes Entscheidungsbaums und weisen Sie die neuen Datenpunkte der Kategorie zu, die die meisten Stimmen erhält.
Die Funktionsweise des Algorithmus lässt sich anhand des folgenden Beispiels besser verstehen:
Zeichenfolge JSON Java
Beispiel: Angenommen, es gibt einen Datensatz, der mehrere Fruchtbilder enthält. Dieser Datensatz wird also dem Random-Forest-Klassifikator übergeben. Der Datensatz wird in Teilmengen unterteilt und jedem Entscheidungsbaum übergeben. Während der Trainingsphase erzeugt jeder Entscheidungsbaum ein Vorhersageergebnis, und wenn ein neuer Datenpunkt auftritt, sagt der Random Forest-Klassifikator basierend auf der Mehrheit der Ergebnisse die endgültige Entscheidung voraus. Betrachten Sie das folgende Bild:
Anwendungen von Random Forest
Es gibt hauptsächlich vier Sektoren, in denen Random Forest am häufigsten verwendet wird:
Vorteile von Random Forest
- Random Forest kann sowohl Klassifizierungs- als auch Regressionsaufgaben ausführen.
- Es ist in der Lage, große Datensätze mit hoher Dimensionalität zu verarbeiten.
- Es erhöht die Genauigkeit des Modells und verhindert das Problem der Überanpassung.
Nachteile von Random Forest
- Obwohl Random Forest sowohl für Klassifizierungs- als auch für Regressionsaufgaben verwendet werden kann, ist es für Regressionsaufgaben nicht besser geeignet.
Python-Implementierung des Random Forest-Algorithmus
Jetzt werden wir den Random-Forest-Algorithmusbaum mit Python implementieren. Hierzu verwenden wir denselben Datensatz „user_data.csv“, den wir in früheren Klassifizierungsmodellen verwendet haben. Durch die Verwendung desselben Datensatzes können wir den Random Forest-Klassifikator mit anderen Klassifizierungsmodellen vergleichen, z Entscheidungsbaumklassifikator, KNN, SVM, logistische Regression usw.
Nachfolgend sind die Implementierungsschritte aufgeführt:
- Datenvorverarbeitungsschritt
- Anpassen des Random-Forest-Algorithmus an den Trainingssatz
- Vorhersage des Testergebnisses
- Testgenauigkeit des Ergebnisses (Erstellung einer Verwirrungsmatrix)
- Visualisierung des Testsatzergebnisses.
1. Datenvorverarbeitungsschritt:
Nachfolgend finden Sie den Code für den Vorverarbeitungsschritt:
String-Java-Array
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Im obigen Code haben wir die Daten vorverarbeitet. Wo wir den Datensatz geladen haben, der wie folgt lautet:
2. Anpassen des Random Forest-Algorithmus an den Trainingssatz:
Jetzt passen wir den Random-Forest-Algorithmus an den Trainingssatz an. Um es anzupassen, importieren wir das RandomForestClassifier Klasse aus der sklearn.ensemble Bibliothek. Der Code ist unten angegeben:
#Fitting Decision Tree classifier to the training set from sklearn.ensemble import RandomForestClassifier classifier= RandomForestClassifier(n_estimators= 10, criterion='entropy') classifier.fit(x_train, y_train)
Im obigen Code nimmt das Klassifikatorobjekt die folgenden Parameter an:
Iterieren einer Karte in Java
Ausgabe:
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False)
3. Vorhersage des Testsatzergebnisses
Da unser Modell an den Trainingssatz angepasst ist, können wir jetzt das Testergebnis vorhersagen. Für die Vorhersage erstellen wir einen neuen Vorhersagevektor y_pred. Unten ist der Code dafür:
#Predicting the test set result y_pred= classifier.predict(x_test)
Ausgabe:
Der Vorhersagevektor wird wie folgt angegeben:
Durch Überprüfen des obigen Vorhersagevektors und des realen Vektors des Testsatzes können wir die falschen Vorhersagen des Klassifikators ermitteln.
4. Erstellen der Verwirrungsmatrix
Jetzt erstellen wir die Verwirrungsmatrix, um die richtigen und falschen Vorhersagen zu ermitteln. Unten ist der Code dafür:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Ausgabe:
Wie wir in der obigen Matrix sehen können, gibt es solche 4+4= 8 falsche Vorhersagen Und 64+28= 92 richtige Vorhersagen.
String-Methoden in Java
5. Visualisierung des Trainingssatzergebnisses
Hier visualisieren wir das Ergebnis des Trainingssatzes. Um das Ergebnis des Trainingssatzes zu visualisieren, zeichnen wir ein Diagramm für den Random-Forest-Klassifikator. Der Klassifikator sagt „Ja“ oder „Nein“ für die Benutzer voraus, die das SUV-Auto entweder gekauft oder nicht gekauft haben, wie wir es in der logistischen Regression getan haben. Unten ist der Code dafür:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Ausgabe:
Das obige Bild ist das Visualisierungsergebnis für den Random Forest-Klassifikator, der mit dem Trainingssatzergebnis arbeitet. Es ist dem Entscheidungsbaumklassifikator sehr ähnlich. Jeder Datenpunkt entspricht jedem Benutzer der user_data, und die violetten und grünen Bereiche sind die Vorhersagebereiche. Der violette Bereich ist für die Benutzer klassifiziert, die kein SUV-Auto gekauft haben, und der grüne Bereich ist für die Benutzer, die den SUV gekauft haben.
Im Random Forest-Klassifikator haben wir also 10 Bäume genommen, die Ja oder NEIN für die Variable „Kauf“ vorhergesagt haben. Der Klassifikator nahm die Mehrheit der Vorhersagen und lieferte das Ergebnis.
6. Visualisierung des Testsatzergebnisses
Jetzt visualisieren wir das Ergebnis des Testsatzes. Unten ist der Code dafür:
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Ausgabe:
Das obige Bild ist das Visualisierungsergebnis für den Testsatz. Wir können überprüfen, ob eine Mindestanzahl falscher Vorhersagen (8) vorliegt, ohne dass das Problem der Überanpassung auftritt. Wir erhalten unterschiedliche Ergebnisse, wenn wir die Anzahl der Bäume im Klassifikator ändern.