Warum viele Köpfe?
Du verstehst, warum ein einzelner Baum oft instabil ist und warum mehrere Perspektiven Stabilität bringen.
Alltagsszene
Wenn du das beste Schnitzel in der Stadt suchst, fragst du selten nur eine Person. Ein einzelner Freund kann einen Spezialgeschmack haben. Fragst du mehrere Menschen, wird das Gesamtbild stabiler. Ensemble Methods übertragen genau diese Idee auf Modelle.
ML-Sprache
Ein einzelner kann bei kleinen Datenänderungen stark schwanken. Ein bündelt mehrere solche Modelle und reduziert damit oft Varianz.
Merksatz
Ein einzelner Baum ist leicht erklärbar, aber oft nervös. Ein Ensemble ist schwerer zu überblicken, aber oft robuster.
Viele Meinungen simulieren
Ensemble-Effekt
Je mehr leicht richtige, aber unabhängige Stimmen du bündelst, desto stabiler wird die Mehrheit.
Was nimmst du mit? Ensembles sind kein Selbstzweck. Sie sollen die Schwächen einzelner Modelle abfedern.
Voting
Du unterscheidest Hard Voting von Soft Voting und siehst, wann Wahrscheinlichkeiten wichtiger sind als bloße Mehrheiten.
Alltagsszene
Drei Ärzte geben eine Diagnose ab. Zwei sagen 'harmlos', einer sagt 'kritisch'. Per Mehrheit wäre die Sache klar. Aber wenn der kritische Arzt zusätzlich sagt, er sei sich zu 95 % sicher, wird die Diskussion anders. Genau das trennt Hard und Soft Voting.
ML-Sprache
zählt Klassenstimmen. mittelt Wahrscheinlichkeiten. Soft Voting ist oft stärker, wenn die Modelle brauchbare predict_proba-Werte liefern. Kurz gesagt: Hard Voting fragt nur 'wer gewinnt?', Soft Voting fragt zusaetzlich 'wie sicher war jede Stimme?'.
Abstimmung spielen
🏋️ Übung: Hard Voting trainieren
Diese Übung stammt direkt aus dem Voting-Notebook. Ergänze nur die Ensemble-Zeile und trainiere danach das Abstimmungsmodell.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import VotingClassifier
X_train = [[1, 1], [1, 2], [2, 1], [3, 3], [4, 4], [4, 5]]
y_train = [0, 0, 0, 1, 1, 1]
model1 = LogisticRegression(random_state=42)
model2 = KNeighborsClassifier()
model3 = DecisionTreeClassifier(random_state=42)
ensemble = # ??? DEINE LÖSUNG ???
ensemble.fit(X_train, y_train)
print(ensemble.predict([[3, 4]])[0])💡 Tipp anzeigen
Du brauchst drei Schätzmodelle in `estimators=[...]` und `voting='hard'`.
✅ Lösung anzeigen
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import VotingClassifier
X_train = [[1, 1], [1, 2], [2, 1], [3, 3], [4, 4], [4, 5]]
y_train = [0, 0, 0, 1, 1, 1]
model1 = LogisticRegression(random_state=42)
model2 = KNeighborsClassifier()
model3 = DecisionTreeClassifier(random_state=42)
ensemble = VotingClassifier(
estimators=[("lr", model1), ("knn", model2), ("dt", model3)],
voting="hard"
)
ensemble.fit(X_train, y_train)
print(ensemble.predict([[3, 4]])[0])Erwartete Ausgabe: 1
Was nimmst du mit? Hard Voting fragt: Wer hat die Mehrheit? Soft Voting fragt zusätzlich: Wie sicher sind die Stimmen?
Bagging & Random Forest
Du verstehst Bootstrap-Samples, Feature-Zufall und warum ein Wald ruhiger ist als ein einzelner Baum.
Alltagsszene
Stell dir eine Stiftung-Warentest-Redaktion vor. Nicht jeder Tester sieht jedes Produkt und jedes Kriterium. Jeder bekommt einen anderen Ausschnitt. Am Ende werden die Bewertungen zusammengeführt. Das ist die Grundidee von Bagging und Random Forest.
ML-Sprache
nutzt Bootstrap-Stichproben mit Zurücklegen. fügt zusätzlich zufällige Feature-Teilmengen hinzu, damit die Bäume weniger korreliert sind. 'Mit Zurücklegen' heißt dabei: Ein Fall darf in einer Stichprobe mehrfach vorkommen, ein anderer dafür auch ganz fehlen.
Wald bauen
Bootstrap-Samples
Jeder Baum sieht einen anderen Datenausschnitt. Manche Fälle sind mehrfach drin, manche fehlen und werden später zu OOB-Testfällen.
🏋️ Übung: Random Forest trainieren
Die Aufgabe basiert auf dem Random-Forest-Codealong. Ergänze das Modell mit 100 Bäumen und `max_features='sqrt'`.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.ensemble import RandomForestClassifier
X_train = [[1, 1], [1, 2], [2, 1], [3, 3], [4, 4], [4, 5], [5, 4], [5, 5]]
y_train = [0, 0, 0, 1, 1, 1, 1, 1]
model = # ??? DEINE LÖSUNG ???
model.fit(X_train, y_train)
print(model.n_estimators)💡 Tipp anzeigen
Nutze `RandomForestClassifier(n_estimators=100, max_features='sqrt', random_state=42)`.
✅ Lösung anzeigen
from sklearn.ensemble import RandomForestClassifier
X_train = [[1, 1], [1, 2], [2, 1], [3, 3], [4, 4], [4, 5], [5, 4], [5, 5]]
y_train = [0, 0, 0, 1, 1, 1, 1, 1]
model = RandomForestClassifier(
n_estimators=100,
max_features="sqrt",
random_state=42
)
model.fit(X_train, y_train)
print(model.n_estimators)Erwartete Ausgabe: 100
Was nimmst du mit? Ein Wald wird robust, wenn seine Bäume nicht alle denselben Ausschnitt und dieselben Merkmale sehen.
Boosting
Du siehst, wie spätere Modelle gezielt die Fehler früherer Modelle aufgreifen.
Alltagsszene
Beim Fahrschultraining übst du nicht in jeder Stunde alles gleich stark. Erst fährst du allgemein, dann konzentrierst du dich besonders auf das Einparken, dann auf die Autobahn. Boosting arbeitet ähnlich: Jede Runde schaut stärker auf die Fälle, die vorher schwierig waren.
ML-Sprache
erhöht Gewichte schwieriger Fälle. lernt schrittweise die Restfehler. Die Modelle arbeiten also nicht parallel wie beim Bagging, sondern nacheinander. Merksatz: Bagging sammelt viele unabhängige Stimmen, Boosting baut eine Fehler-Korrektur-Kette.
Fehler-Kette
🏋️ Übung: AdaBoost-Runden denken
Die Übung lehnt sich an das AdaBoost-Notebook an. Ergänze die Schleife, damit für mehrere Rundenzahlen der Fehler gesammelt wird.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
errors = []
x_range = range(10, 40, 10)
for rounds in x_range:
error = # ??? DEINE LÖSUNG ???
errors.append(error)
print(len(errors))💡 Tipp anzeigen
Im Notebook liefert `adaboost_clf(...)` ein Tupel aus Trainings- und Testfehler. Du brauchst hier nur den Testfehler.
✅ Lösung anzeigen
errors = []
x_range = range(10, 40, 10)
for rounds in x_range:
error = adaboost_clf(Y_train, X_train, Y_test, X_test, rounds, clf_tree)[1]
errors.append(error)
print(len(errors))Erwartete Ausgabe: 3
Was nimmst du mit? Boosting versucht nicht, viele unabhängige Stimmen zu sammeln. Es baut gezielt eine Fehler-Korrektur-Kette auf.
Stacking
Du lernst, wie ein Meta-Modell entscheidet, welchem Basis-Modell es in welcher Lage mehr traut.
Alltagsszene
In einer Casting-Show sitzen unterschiedliche Experten in der Jury. Der eine hört auf Technik, der andere auf Bühnenpräsenz. Ein zusätzlicher Schiedsrichter könnte lernen, in welcher Situation welche Jury-Stimme am meisten zählt. Genau das ist Stacking.
ML-Sprache
heißt das obere Modell. Es bekommt nicht die Rohdaten, sondern die Vorhersagen der Basis-Modelle als neue Eingaben. Stacking lernt also die Kombination der Stimmen, während Voting sie direkt zählt oder mittelt.
Welchem Modell würdest du trauen?
🏋️ Übung: StackingClassifier aufsetzen
Die Vorlage stammt aus dem Voting-Notebook. Ergänze die Stacking-Zeile mit den drei Basis-Modellen und einer logistischen Regression als finalem Modell.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, StackingClassifier
estimators = [
("dt", DecisionTreeClassifier(random_state=42)),
("knn", KNeighborsClassifier()),
("rf", RandomForestClassifier(random_state=42))
]
clf = # ??? DEINE LÖSUNG ???
print(type(clf).__name__)💡 Tipp anzeigen
Nutze `StackingClassifier(estimators=..., final_estimator=LogisticRegression())`.
✅ Lösung anzeigen
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, StackingClassifier
estimators = [
("dt", DecisionTreeClassifier(random_state=42)),
("knn", KNeighborsClassifier()),
("rf", RandomForestClassifier(random_state=42))
]
clf = StackingClassifier(
estimators=estimators,
final_estimator=LogisticRegression()
)
print(type(clf).__name__)Erwartete Ausgabe: StackingClassifier
Was nimmst du mit? Stacking ist mehr als Abstimmen. Es lernt, wann welche Modellstimme besonders nützlich ist.
Interpretation
Du siehst, wie man trotz vieler Modelle noch Hinweise darauf bekommt, welche Merkmale wichtig waren.
Alltagsszene
Wenn ein Ärzteteam eine Diagnose stellt, willst du trotzdem wissen, welche Blutwerte oder Symptome den Ausschlag gaben. Bei Ensembles ist das ähnlich: Das Endurteil ist stark, aber wir brauchen Werkzeuge, um nachträglich zu verstehen, was wichtig war.
ML-Sprache
ist ein erster Blick auf die Frage: Welche Merkmale wurden im Ensemble besonders oft oder besonders nützlich verwendet?
Merkmale gewichten
🏋️ Übung: Wichtigstes Merkmal finden
Die Vorlage orientiert sich am Random-Forest-Codealong. Ergänze die Ausgabezeile so, dass das wichtigste Merkmal gefunden wird.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
features = ["sleep", "steps", "age", "stress"]
importance = [0.41, 0.27, 0.12, 0.20]
best_feature = # ??? DEINE LÖSUNG ???
print(best_feature)💡 Tipp anzeigen
Finde erst den Index des größten Werts in `importance`.
✅ Lösung anzeigen
features = ["sleep", "steps", "age", "stress"]
importance = [0.41, 0.27, 0.12, 0.20]
best_feature = features[importance.index(max(importance))]
print(best_feature)Erwartete Ausgabe: sleep
Was nimmst du mit? Auch starke Ensembles brauchen eine gute Nach-Erklärung, sonst bleibt das Modell für Fachabteilungen eine Black Box.
Praxisvergleich
Du ordnest den kompletten Workflow vom Baseline-Modell bis zum Ensemble-Vergleich.
Alltagsszene
Im Arbeitsalltag reicht es nicht, nur ein Random-Forest-Modell hinzustellen. Du brauchst eine saubere Reihenfolge: Daten vorbereiten, Baseline prüfen, Ensembles vergleichen, Metriken lesen und dann erst entscheiden, was wirklich besser ist.
ML-Sprache
Ein guter Ensemble-Workflow vergleicht zuerst ein einfaches Baseline-Modell, dann Bagging/Voting/Boosting-Varianten und liest danach Metriken wie Accuracy, F-Score oder ROC-AUC im Test. Sonst weißt du am Ende nicht, ob das Ensemble wirklich besser war oder nur beeindruckender klang.
Merksatz
Erst Baseline, dann Ensemble, dann Vergleich. Sonst weißt du nie, ob die zusätzliche Komplexität überhaupt etwas gebracht hat.
Workflow ordnen
Klicke die Schritte in der richtigen Reihenfolge an.
Was nimmst du mit? Ensemble Methods sind am stärksten, wenn du sie nicht nur trainierst, sondern auch fair mit einer einfachen Referenz vergleichst.