Random Forest Classifier Tutorial: Verwendung baumbasierter Algorithmen für maschinelles Lernen

Baumbasierte Algorithmen sind beliebte Methoden des maschinellen Lernens, mit denen überwachte Lernprobleme gelöst werden. Diese Algorithmen sind flexibel und können jede Art von Problem lösen (Klassifizierung oder Regression).

Baumbasierte Algorithmen verwenden in der Regel den Mittelwert für kontinuierliche Merkmale oder den Modus für kategoriale Merkmale, wenn Vorhersagen für Trainingsmuster in den Regionen getroffen werden, zu denen sie gehören. Sie liefern auch Vorhersagen mit hoher Genauigkeit , Stabilität und einfacher Interpretation .

Beispiele für baumbasierte Algorithmen

Es gibt verschiedene baumbasierte Algorithmen, die Sie verwenden können, z

  • Entscheidungsbäume
  • Zufälliger Wald
  • Gradientenverstärkung
  • Absacken (Bootstrap Aggregation)

Daher sollte jeder Datenwissenschaftler diese Algorithmen lernen und in seinen maschinellen Lernprojekten verwenden.

In diesem Artikel erfahren Sie mehr über den Random Forest-Algorithmus. Nach Abschluss dieses Artikels sollten Sie mit dem Random Forest-Algorithmus vertraut sein, um Vorhersagemodelle für Klassifizierungsprobleme mit Scikit-Learn zu lösen und zu erstellen.

Was ist zufälliger Wald?

Random Forest ist einer der beliebtesten baumbasierten überwachten Lernalgorithmen. Es ist auch das flexibelste und einfachste zu bedienen.

Der Algorithmus kann verwendet werden, um sowohl Klassifizierungs- als auch Regressionsprobleme zu lösen. Zufällige Wälder neigen dazu, Hunderte von zu kombinierenEntscheidungsbäumeund trainiert dann jeden Entscheidungsbaum an einer anderen Stichprobe der Beobachtungen.

Die endgültigen Vorhersagen des zufälligen Waldes werden durch Mitteln der Vorhersagen jedes einzelnen Baums getroffen.

Die Vorteile zufälliger Wälder sind zahlreich. Die einzelnen Entscheidungsbäume passen sich in der Regel den Trainingsdaten an, aber zufällige Gesamtstrukturen können dieses Problem durch Mitteln der Vorhersageergebnisse von verschiedenen Bäumen abmildern . Dies gibt zufälligen Wäldern eine höhere Vorhersagegenauigkeit als einem einzelnen Entscheidungsbaum.

Der Random Forest-Algorithmus kann Ihnen auch dabei helfen, Funktionen zu finden, die in Ihrem Dataset wichtig sind . Es liegt dem Boruta-Algorithmus zugrunde, der wichtige Merkmale in einem Datensatz auswählt.

Random Forest wurde in einer Vielzahl von Anwendungen verwendet, um beispielsweise Kunden im E-Commerce Empfehlungen zu verschiedenen Produkten zu geben.

In der Medizin kann ein zufälliger Waldalgorithmus verwendet werden, um die Krankheit des Patienten durch Analyse der Krankenakte des Patienten zu identifizieren.

Auch im Bankensektor kann damit leicht festgestellt werden, ob der Kunde betrügerisch oder legitim ist.

Wie funktioniert der Random Forest-Algorithmus?

Der Random Forest-Algorithmus führt die folgenden Schritte aus:

Schritt 1 : Der Algorithmus wählt zufällige Stichproben aus dem bereitgestellten Datensatz aus.

Schritt 2: Der Algorithmus erstellt für jede ausgewählte Stichprobe einen Entscheidungsbaum. Dann erhält es ein Vorhersageergebnis von jedem erstellten Entscheidungsbaum.

Schritt 3: Die Abstimmung wird dann für jedes vorhergesagte Ergebnis durchgeführt. Für ein Klassifizierungsproblem wird der Modus verwendet , und für ein Regressionsproblem wird der Mittelwert verwendet .

Schritt 4 : Und schließlich wählt der Algorithmus das am meisten gewählte Vorhersageergebnis als endgültige Vorhersage aus.

Zufälliger Wald in der Praxis

Nachdem Sie die Vor- und Nachteile des Algorithmus für zufällige Gesamtstrukturen kennen, erstellen wir einen Klassifikator für zufällige Gesamtstrukturen.

Wir werden einen zufälligen Waldklassifikator unter Verwendung des Pima Indians Diabetes-Datensatzes erstellen. Der Pima Indians Diabetes-Datensatz beinhaltet die Vorhersage des Ausbruchs von Diabetes innerhalb von 5 Jahren auf der Grundlage der bereitgestellten medizinischen Details. Dies ist ein binäres Klassifizierungsproblem.

Unsere Aufgabe ist es, ein Modell des Pima Indian Diabetes-Datensatzes zu analysieren und zu erstellen, um vorherzusagen, ob ein bestimmter Patient aufgrund anderer unabhängiger Faktoren einem Diabetesrisiko ausgesetzt ist.

Zunächst importieren wir wichtige Pakete, mit denen wir das Dataset laden und einen zufälligen Gesamtstrukturklassifizierer erstellen. Wir werden die Scikit-Learn-Bibliothek verwenden, um den Random Forest-Algorithmus zu laden und zu verwenden.

# import important packages import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score from sklearn.preprocessing import StandardScaler, MinMaxScaler import pandas_profiling from matplotlib import rcParams import warnings warnings.filterwarnings("ignore") # figure size in inches rcParams["figure.figsize"] = 10, 6 np.random.seed(42)

Datensatz

Laden Sie dann den Datensatz aus dem Datenverzeichnis:

# Load dataset data = pd.read_csv("../data/pima_indians_diabetes.csv")

Jetzt können wir die Stichprobe des Datensatzes beobachten.

 # show sample of the dataset data.sample(5)

Wie Sie sehen können, haben wir in unserem Datensatz verschiedene Funktionen mit numerischen Werten.

Lassen Sie uns die Liste der Funktionen in diesem Datensatz verstehen.

# show columns data.columns

In diesem Datensatz gibt es 8 Eingabefunktionen und 1 Ausgabe- / Zielfunktion. Es wird angenommen, dass fehlende Werte mit Nullwerten codiert sind. Die Variablennamen haben folgende Bedeutung (vom ersten bis zum letzten Merkmal):

  • Anzahl der Schwangerschaften.
  • Plasmaglucosekonzentration a 2 Stunden in einem oralen Glucosetoleranztest.
  • Diastolischer Blutdruck (mm Hg).
  • Trizeps-Hautfaltenstärke (mm).
  • 2 Stunden Seruminsulin (mu U / ml).
  • Body Mass Index (Gewicht in kg / (Größe in m) ^ 2).
  • Diabetes-Stammbaumfunktion.
  • Alter Jahre).
  • Klassenvariable (0 oder 1).

Anschließend teilen wir den Datensatz in unabhängige Features und Ziel-Features auf. Unsere Zielfunktion für diesen Datensatz heißt Klasse.

# split data into input and taget variable(s) X = data.drop("class", axis=1) y = data["class"]

Vorverarbeitung des Datensatzes

Before we create a model we need to standardize our independent features by using the standardScaler method from scikit-learn.

# standardize the dataset scaler = StandardScaler() X_scaled = scaler.fit_transform(X)

You can learn more on how and why to standardize your data from this article by clicking here.

Splitting the dataset into Training and Test data

We now split our processed dataset into training and test data. The test data will be 10% of the entire processed dataset.

# split into train and test set X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42 )

Building the Random Forest Classifier

Now is time to create our random forest classifier and then train it on the train set. We will also pass the number of trees (100) in the forest we want to use through theparameter called n_estimators.

# create the classifier classifier = RandomForestClassifier(n_estimators=100) # Train the model using the training sets classifier.fit(X_train, y_train)

The above output shows different parameter values of the random forest classifier used during the training process on the train data.

After training we can perform prediction on the test data.

# predictin on the test set y_pred = classifier.predict(X_test)

Then we check the accuracy using actual and predicted values from the test data.

# Calculate Model Accuracy print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8051948051948052

Our accuracy is around 80.5% which is good. But we can always make it better.

Identify Important Features

As I said before, we can also check the important features by using the feature_importances_ variable from the random forest algorithm in scikit-learn.

# check Important features feature_importances_df = pd.DataFrame( {"feature": list(X.columns), "importance": classifier.feature_importances_} ).sort_values("importance", ascending=False) # Display feature_importances_df

The figure above shows the relative importance of features and their contribution to the model. We can also visualize these features and their  scores using the seaborn and matplotlib libraries.

# visualize important featuers # Creating a bar plot sns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance) # Add labels to your plt.xlabel("Feature Importance Score") plt.ylabel("Features") plt.title("Visualizing Important Features") plt.xticks( rotation=45, horizontalalignment="right", fontweight="light", fontsize="x-large" ) plt.show()

From the figure above, you can see the triceps_skinfold_thickness feature has low importance and does not contribute much to the prediction.

This means that we can remove this feature and train our random forest classifier again and then see if it can improve its performance on the test data.

# load data with selected features X = data.drop(["class", "triceps_skinfold_thickness"], axis=1) y = data["class"] # standardize the dataset scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # split into train and test set X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42 )

We will train the random forest algorithm with the selected processed features from our dataset, perform predictions, and then find the accuracy of the model.

# Create a Random Classifier clf = RandomForestClassifier(n_estimators=100) # Train the model using the training sets clf.fit(X_train, y_train) # prediction on test set y_pred = clf.predict(X_test) # Calculate Model Accuracy, print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8181818181818182

Now the model accuracy has increased from 80.5% to 81.8% after we removed the least important feature called triceps_skinfold_thickness.

This suggests that it is very important to check important features and see if you can remove the least important features to increase your model's performance.

Wrapping up

Tree-based algorithms are really important for every data scientist to learn. In this article, you've learned the basics of tree-based algorithms and how to create a classification model by using the random forest algorithm.

I also recommend you try other types of tree-based algorithms such as the Extra-trees algorithm.

You can download the dataset and notebook used in this article here: //github.com/Davisy/Random-Forest-classification-Tutorial

Congratulations, you have made it to the end of this article!

If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! I can also be reached on Twitter @Davis_McDavid