Ensemble-Modelle Tutorial: Ensemble-Learning-Techniken entdecken

In diesem Tutorial lernst du, was Ensembles sind und wie sie die Performance eines Machine-Learning-Modells verbessern.

Aktualisiert 18. Sept. 2026 · 14 Min. lesen

Mit KI erkunden

Machine-Learning-Modelle sind keine klassischen Softwarelösungen. Diese Modelle brauchen laufend Aktualisierungen, sobald neue Daten vorliegen, damit Vorhersagen präzise und verlässlich bleiben. In komplexen oder sensiblen Szenarien reicht ein einzelnes Modell oft nicht aus, um optimale Ergebnisse zu erzielen – hier spielt Ensemble Modeling seine Stärken aus.

In diesem konzeptionellen Tutorial erfährst du, was Ensemble Modeling im Machine Learning ist und wie es die Gesamtperformance deiner Modelle steigern kann. Anschließend geben wir einen Überblick über gängige Ensemble-Methoden und zeigen ein praxisnahes Beispiel mit einer Schritt-für-Schritt-Implementierung in Python.

Unser Tutorial Ensemble Learning in R mit SuperLearner zeigt dir, wie du mit dem SuperLearner-Paket in R auf Basis von Ensemble Learning deine Machine-Learning-Ergebnisse verbesserst.

Ensemble-Modelle im Machine Learning

Stell dir eine Musikmanagerin vor, die an einem internationalen Wettbewerb teilnimmt. Sie hat Zugriff auf eine große Bandbreite an Musikerinnen und Musikern mit unterschiedlichen Stärken:

Klassische Musiker, die traditionelle Werke komponieren können.
Elektronische Musiker, die elektronische Instrumente virtuos einsetzen.
Jazzmusiker mit starkem Improvisationstalent.
Solistinnen und Solisten, die komplexe Soli spielen und ihre Technik zeigen.

Angesichts dieser Vielfalt kann die Managerin die Talente passend kombinieren und so eine einzigartige, einprägsame Performance schaffen.

Denke bei Ensemble-Modellen an ein Orchester: Jede Person beherrscht ihr Instrument – Klavier, Trompete, Schlagzeug und mehr. Zusammengenommen entsteht eine harmonische Melodie.

Ensemble Learning folgt genau dieser Logik:

Es kombiniert mehrere Algorithmen, um bessere Vorhersagen zu erzielen als mit einem einzelnen Modell. Eine feste Anzahl an Modellen gibt es nicht – je nach Zielsetzung können mehr oder weniger Modelle sinnvoll sein.

Modellfehler und wie Ensembles ihn reduzieren

Der Fehler eines beliebigen ML-Modells lässt sich mathematisch in drei Komponenten aufteilen:

Bias + Varianz + irreduzibler Fehler

Warum ist das hier relevant? Um zu verstehen, was in einem Ensemble-Modell passiert, musst du wissen, wodurch Fehler im Modell entstehen.

Schauen wir uns die Fehlerarten an:

Bias-Fehler

Er misst, wie stark die vorhergesagten Werte im Durchschnitt vom tatsächlichen Wert abweichen. Ein hoher Bias bedeutet ein unterperformendes Modell, das wichtige Zusammenhänge verfehlt.

Varianz

Varianz quantifiziert, wie stark Vorhersagen für die gleiche Beobachtung schwanken. Ein Modell mit hoher Varianz überfitttet auf die Trainingsdaten und liefert bei neuen Beobachtungen schwache Ergebnisse. Die folgende Grafik macht das deutlicher (roter Punkt = wahrer Wert, blaue Punkte = Vorhersagen):

Erhöhst du die Modellkomplexität, sinkt der Fehler zunächst durch geringeren Bias. Ab einem Punkt kippt das jedoch: Mit weiter steigender Komplexität überfittet das Modell und die Varianz steigt.

Jetzt, da die Grundlagen klar sind, sehen wir uns die wichtigsten Ensemble-Techniken an:

Arten von Ensemble-Methoden

Es gibt verschiedene Ensemble-Methoden – jede mit eigenen Vor- und Nachteilen. Dieser Abschnitt hilft dir, die passende Methode für deinen Use Case zu wählen.

Vorab kurz zu Base- und Meta-Learners, damit die nächsten Konzepte leichter fallen:

Base Learners bilden die erste Ebene in der Ensemble-Architektur und werden jeweils separat trainiert, um Vorhersagen zu treffen.
Meta Learners stehen eine Ebene darüber und werden auf den Ausgaben der Base Learners trainiert.

Bagging

Bagging steht für Bootstrap Aggregation. Diese Technik ist verwandt mit dem Random Forest; beim Bagging werden jedoch alle Prädiktoren genutzt, während Random Forest in jedem Baum nur eine Prädiktoren-Teilmenge betrachtet.

Beim Bagging wird per Ziehen mit Zurücklegen eine Zufallsstichprobe aus dem Trainingssatz gebildet, wodurch Instanzen mehrfach vorkommen können. Die Hauptschritte sind:

Erzeugen mehrerer Bootstrap-Resamples.
Ausführen eines Algorithmus auf jedem Resample zur Vorhersage.
Kombinieren der Vorhersagen über Mittelwertbildung bzw. Mehrheitsentscheidung (bei Klassifikation).

Bagging bringt für Klassifikations- und Regressionsaufgaben einige klare Vor- und Nachteile mit sich.

Vorteile

Einfacher Modellierungsprozess ohne tiefgehende Mathematik; kann mit fehlenden Werten umgehen.
scikit-learn erleichtert die Umsetzung. Sämtliche Module zum Kombinieren der Base-Learner-Vorhersagen sind vorhanden.
Wirkt stark varianzreduzierend bei hochvarianten Klassifikatoren – hilfreich bei hochdimensionalen Daten, um Generalisierung zu verbessern.
Liefert eine unverzerrte Schätzung des Out-of-Bag-Fehlers, also des durchschnittlichen Fehlers/Verlusts über alle Klassifikatoren.

Nachteile

Rechenintensiv, da viele Modelle trainiert werden.
Durch das Mitteln der Vorhersagen wird die Interpretation des Endergebnisses erschwert.

Boosting

Boosting arbeitet sequentiell: Die Vorhersagen des aktuellen Modells fließen in das nächste ein. Jedes Modell richtet seinen Fokus iterativ stärker auf die von Vorgängern fehlklassifizierten Beobachtungen. Der Ablauf im Überblick:

Vorteile

Wie Bagging gut verständlich und einfach zu implementieren; keine aufwendige Vorverarbeitung nötig; geht mit fehlenden Werten um.
Reduziert Bias effizient.
Boosting-Algorithmen gewichten während des Trainings besonders aussagekräftige Features höher. Das senkt die Dimensionalität und verkürzt die Rechenzeit.

Nachteile

Durch die Sequenz korrigiert jedes Modell Fehler des Vorgängers – Ausreißer können so das Gesamtergebnis stark beeinflussen.
Aus demselben Grund ist Boosting schlechter skalierbar.

Stacking

Stacking ähnelt dem Boosting: Die Vorhersagen der Base Learners werden gestapelt und dienen als Eingabe, um den Meta Learner zu trainieren, der robustere Vorhersagen erzeugt. Anschließend trifft der Meta Learner die finalen Vorhersagen. Während Bagging und Boosting meist homogene Base Learners nutzen, setzt Stacking häufig auf heterogene.

Vorteile

Nutzt die Stärken mehrerer leistungsfähiger Modelle für Klassifikation und Regression.
Wie andere Ensemble-Modelle erzielt Stacking oft höhere Genauigkeit als einzelne Modelle für sich.

Nachteile

Komplexe Basismodelle erhöhen das Overfitting-Risiko.
Unterschiedliche Trainingsebenen machen die Implementierung der Stacking-Architektur aufwendiger.

Blending

Blending ist Stacking sehr ähnlich. Die Daten werden in Training, Holdout und Test aufgeteilt. Die Meta Learners werden auf den Trainingsdaten trainiert; ihre Vorhersagen werden mit den Holdout-Daten kombiniert, um das finale Meta-Modell zu bauen, das dann auf den Testdaten die Endvorhersagen trifft.

Vorteile

Wie Stacking und andere Ensemble-Methoden kann Blending die Performance des Endmodells deutlich steigern.
Diese Technik hat schon viele Wettbewerbe entschieden.

Nachteile

Die Datenaufteilung nach Blending-Architektur reduziert Trainingsdaten für Base-Modelle und kann die Leistung schmälern.
Wie bei anderen Ensembles leidet die Interpretierbarkeit durch höhere Komplexität – Business-Insights sind schwerer abzuleiten.

Voting

Beim Voting werden mehrere Modelle unabhängig trainiert; ihre Vorhersagen werden per Hard Voting, Soft Voting oder gewichtetes Voting zu einer Endvorhersage kombiniert:

Hard Voting: Die häufigste Klassenprognose aller Modelle setzt sich durch.
Soft Voting: Jedes Modell liefert Wahrscheinlichkeiten statt binärer Vorhersagen; die Klasse mit der höchsten Gesamtwahrscheinlichkeit wird gewählt.
Gewichtetes Voting: Modelle mit höherer erwarteter Güte erhalten mehr Gewicht beim Abstimmen.

Vorteile

Einfacher umzusetzen als Stacking oder Blending; kein komplexes Finetuning nötig.
Mehrere Base Learners machen das System weniger anfällig für Ausreißer einzelner Modelle – Vorhersagen werden stabiler.

Nachteile

Konfliktierende Modellvorhersagen können die Entscheidungsfindung erschweren.
Mehr Modelle führen nicht automatisch zu besserer Gesamtperformance.

Cascading

Cascading nutzt einen Stacking-Ansatz, jedoch mit nur einem Modell pro Schicht. Das erste Modell wird auf allen Trainingsdaten trainiert, das nächste auf dessen Ausgaben usw. Ziel ist, komplexe Muster in den Daten schrittweise zu erfassen und dadurch bessere Vorhersagen zu ermöglichen.

Vorteile

Jedes nachfolgende Modell ist auf die Ausgaben des vorherigen spezialisiert, wodurch Rauschen reduziert wird.
Robuster gegenüber Overfitting und oft praxistauglich auf Realweltdaten.

Nachteile

Die Umsetzung ist komplex, da jedes Modell in der Kette separat trainiert werden muss.
Die optimale Architektur zu finden, erfordert viel Experimentieren und Finetuning.

Überblick über Ensemble-Algorithmen

Nachdem wir die Arten von Ensemble-Modellen betrachtet haben, folgt nun ein kurzer Überblick über einige populäre Verfahren.

Random Forest

Random Forest ist weit verbreitet und eignet sich für Klassifikation und Regression. Ein Random Forest besteht aus vielen Entscheidungsbäumen, die per Bagging trainiert werden. Das Gesamtergebnis ergibt sich aus dem Mittel der Einzelbaum-Vorhersagen.

Wichtige Hyperparameter sind Knotengröße, Anzahl der Bäume und Anzahl der gesampelten Features.

Woher kommt die Zufälligkeit im Random Forest?

Feature Bagging (Feature-Randomness) zieht zufällig Feature-Teilmengen, um die Korrelation zwischen Bäumen zu senken. Anders als einzelne Entscheidungsbäume, die alle möglichen Splits prüfen, betrachtet Random Forest nur eine Feature-Teilmenge. Mehr dazu im Random-Forest-Klassifikations-Tutorial.

XGBoost

Extreme Gradient Boosting (XGBoost) wird für Klassifikation und Regression eingesetzt. XGBoost ist für hohe Effizienz und Skalierbarkeit ausgelegt und implementiert das Framework der Gradient-Boosting-Entscheidungsbäume.

Es eignet sich für sehr große Datensätze und unterstützt verteilte Umgebungen wie Hadoop, MPI (Message Passing Inference) und SGI (Sun Grid Engine). Mehr dazu im XGBoost-Tutorial.

AdaBoost

Adaptive Boosting (AdaBoost) ist einer der ersten erfolgreichen Boosting-Classifier für binäre Klassifikation. „Adaptiv“ bedeutet, dass Instanzen je nach Fehler neu gewichtet werden – fehlklassifizierte Beispiele erhalten höhere Gewichte. Lies mehr zu AdaBoost Classification in Python in unserem separaten Tutorial.

Schritt-für-Schritt-Implementierung von Ensemble-Modellen

Jetzt kennst du die Grundidee hinter Ensemble Modeling und einige Verfahren. Im nächsten Schritt setzen wir das Ganze in Python um.

Umgebung einrichten

Installiere zunächst Python sowie folgende Bibliotheken:

pandas zum Laden von DataFrames.
scikit-learn für vorhandene Machine-Learning-Algorithmen.
seaborn und matplotlib für Visualisierungen.

Du kannst diese Bibliotheken mit pip, dem Python-Paketmanager, so installieren:

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Zur Veranschaulichung nutzen wir die Loan-Daten aus DataLab. Den Code findest du ebenfalls in DataLab in diesem Workbook. Du kannst eine Kopie erstellen und den Code direkt im Browser bearbeiten und ausführen – ganz ohne lokale Installation.

Die Daten verstehen

Der Datensatz enthält 9.500 Kredite mit Informationen zur Kreditstruktur, zur kreditnehmenden Person und dazu, ob der Kredit vollständig zurückgezahlt wurde. Das Feld not.fully.paid kennzeichnet dies. Die ersten fünf Zeilen siehst du hier:

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

Mit der Funktion info() bekommst du u. a. folgende Eckdaten zum Datensatz:

9.578 Zeilen (0 bis 9577) und 14 Spalten; alle numerisch außer purpose (Typ object), das die textliche Beschreibung des Kreditgrunds enthält.
Das Tag non-null an jeder Spalte zeigt, dass dort keine fehlenden Werte vorhanden sind.

loan_data.info()

Es liegt eine Klassenunwucht vor: Deutlich mehr Beobachtungen mit Klasse 0 (8045) als mit Klasse 1 (1533).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Trainierst du Modelle auf solch unausgewogenen Daten, leidet die Gesamtperformance.

Ein Ansatz ist Undersampling: Wir reduzieren die Mehrheit (Klasse 0), sodass gleich viele Beobachtungen wie in Klasse 1 vorliegen. Vorgehen:

Ermittle zunächst die Anzahl der Klasse-1-Beobachtungen.
Ziehe N Zufallsbeobachtungen aus Klasse 0, wobei N der Größe des Klasse-1-DataFrames entspricht.
Konkatenieren der beiden DataFrames.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

Das Tutorial Diving Deep with Imbalanced Data liefert weitere Techniken zum Umgang mit unausgewogenen Datensätzen.

Nach dem Undersampling erhalten wir:

Insgesamt 3.066 Beobachtungen und 14 Spalten.

Die finale, balancierte Verteilung siehst du hier:

Daten für das Training vorbereiten

Im Datensatz haben nicht alle Features die gleiche Skala, und manche Modelle wie KNN reagieren empfindlich darauf. Wir bringen daher die Merkmalsbereiche mit MinMaxScaler auf eine einheitliche Skala zwischen 0 und 1.

Außerdem entfernen wir der Einfachheit halber die Spalte purpose, da sie zusätzliche Vorverarbeitung erfordert.

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Unnötige Spalte 'purpose' entfernen und Daten beziehen
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Wie bei jeder Vorhersageaufgabe teilen wir in Trainings- und Testdaten. Hier nutzen wir 77% fürs Training und 33% fürs Testing.

Der Random-State wird (bei uns 2023) gesetzt, um Reproduzierbarkeit sicherzustellen.

Stratify sorgt dafür, dass die Zielvariable y in Train und Test gleichmäßig verteilt ist.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Alle Modelle folgen nun dem Ablauf: auf Trainingsdaten trainieren, auf Testdaten vorhersagen und die Performance auswerten.

Bagging-Modell

Als Bagging-Modell verwenden wir Random Forest – der Einfachheit halber mit Standardparametern.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Modell definieren
random_forest_model = RandomForestClassifier()
# Modell trainieren
random_forest_model.fit(X_train, y_train)

Nach dem Training bestimmen wir die Performance mit der Funktion accuracy_score wie folgt:

# Vorhersagen treffen
y_pred = random_forest_model.predict(X_test)

# Performance berechnen
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy)

Die Ausgabe ergibt 0.6156, also 61,56%.

Jetzt vergleichen wir das mit einer Blending-Aggregation.

Blending-Modell

Für Blending nutzen wir zwei Base-Modelle: einen Decision Tree und einen K-Nearest-Neighbors-Classifier. Ein finales Regressionsmodell trifft die Endvorhersagen.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

Die ursprünglichen Trainingsdaten teilen wir in neue Trainings- und Validierungsdaten. Die Basismodelle werden auf den Trainingsdaten trainiert.

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)

Anschließend entstehen zwei DataFrames aus den Vorhersagen dieser Basismodelle:

Ein DataFrame mit den Vorhersagen auf den Validierungsdaten, konkateniniert mit den Original-Validierungsdaten.
Ein zweiter DataFrame mit den Vorhersagen auf den Testdaten, konkateniniert mit den Original-Testdaten.

# Decision-Tree-Modell
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# KNN-Modell
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

Das finale Logistische-Regression-Modell wird mit den konkateninierten Validierungsdaten trainiert und mit den konkateninierten Testdaten bewertet.

x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Logistische Regression
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)

Mit .score() wird standardmäßig die Accuracy berechnet – ohne explizite Vorhersagen anzugeben.

Das Ergebnis ist 0.6383, also 63,83% – rund 2% mehr als beim Random Forest. Damit schneidet das Blending-Modell hier am besten ab.

Unser Kurs Ensemble Methods in Python und Machine Learning with Tree-Based Models in R sind ideale nächste Schritte, um tiefer in die Welt der Ensemble-Methoden einzutauchen – in Python bzw. R.

Fazit

Wir haben verschiedene Arten von Ensemble Modeling mit ihren Merkmalen, Stärken und Schwächen betrachtet. Außerdem gab es einen Überblick über Ensemble-Algorithmen wie Random Forest, Adaboost, XGBoost, Gradient Boosting Trees und Gradient Boosting Machines.

Beim Aufbau von Ensemble-Modellen solltest du Vor- und Nachteile im Blick behalten, um bessere Business-Entscheidungen abzuleiten.

FAQs

Was ist der Unterschied zwischen homogenen und heterogenen Learners?

Homogene Learners nutzen denselben Algorithmustyp und ähnliche Hyperparameter. Ein Random Forest kann als Ensemble homogener Learners betrachtet werden.

Heterogene Learners kombinieren unterschiedliche Algorithmen und Hyperparameter. Random Forest, Neural Network und KNN können gemeinsam heterogene Learners in einem Ensemble bilden.

Welche Vorteile haben Ensemble-Modelle gegenüber Einzelmodellen?

Mit Ensembles lassen sich häufig bessere Vorhersagen erzielen als mit einem einzelnen Modell.

Was ist die Einschränkung von Ensemble-Modellen?

Ensembles leiden oft unter geringerer Interpretierbarkeit – das vom Ensemble gelernte Wissen ist für Endnutzende schwer nachvollziehbar.

Wann solltest du auf Ensemble-Modelle verzichten?

Unter anderem, wenn hohe Interpretierbarkeit gefordert ist, nur wenige Daten vorliegen, harte Echtzeitanforderungen bestehen oder die Rechenkosten sehr hoch sind.