Baumbasierte Modelle: Entscheidungsbäume und Random Forests
Erstellen und optimieren Sie Entscheidungsbaum- und Ensemble-Forest-Modelle.
Baumbasierte Modelle: Entscheidungsbäume und Random Forests ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.
Konzepte von Entscheidungsbäumen
Ein Entscheidungsbaum teilt Daten auf, indem er eine Folge binärer Fragen stellt. Jeder innere Knoten enthält einen Schwellenwert für ein Merkmal; jedes Blatt entspricht einer Vorhersage.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print("Depth:", model.get_depth())
print("Leaves:", model.get_n_leaves())DecisionTreeClassifier
Wichtige Hyperparameter: max_depth, min_samples_split, min_samples_leaf. Tiefere Bäume neigen zu Overfitting, flachere Bäume zu Underfitting.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = DecisionTreeClassifier(max_depth=5, min_samples_leaf=5)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))DecisionTreeRegressor
Entscheidungsbäume können auch für Regression verwendet werden, indem sie in jedem Blatt den Mittelwert des Zielwerts vorhersagen.
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
X, y = make_regression(noise=15, random_state=0)
model = DecisionTreeRegressor(max_depth=4).fit(X, y)
print("RMSE:", mean_squared_error(y, model.predict(X))**0.5)Merkmalswichtigkeit
model.feature_importances_ liefert die relative Wichtigkeit jedes Merkmals, basierend auf der Verringerung der Unreinheit.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
model = DecisionTreeClassifier().fit(X, y)
for name, imp in sorted(zip(feature_names, model.feature_importances_), key=lambda x: -x[1]):
print(f"{name}: {imp:.3f}")Überblick über Random Forest
Ein Random Forest trainiert viele dekorrelierte Entscheidungsbäume auf Bootstrap-Stichproben und mittelt ihre Vorhersagen – dadurch wird die Varianz reduziert, ohne den Bias zu erhöhen.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = RandomForestClassifier(n_estimators=100, random_state=0)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))RandomForestRegressor
Random Forests funktionieren ebenso gut für Regression.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import r2_score
X, y = make_regression(noise=10, random_state=0)
model = RandomForestRegressor(n_estimators=100, random_state=0).fit(X, y)
print("R²:", r2_score(y, model.predict(X)))Out-of-Bag-Score
Setzen Sie oob_score=True, um einen Validierungswert ohne zusätzlichen Aufwand zu erhalten. Dafür werden Stichproben verwendet, die nicht in der Bootstrap-Stichprobe des jeweiligen Baums enthalten sind; ein separater Testsatz ist nicht erforderlich.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(random_state=0)
model = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=0).fit(X, y)
print("OOB score:", model.oob_score_)Gradient Boosting
Gradient Boosting (GBM) trainiert Bäume nacheinander, wobei jeder die Fehler des vorherigen korrigiert. Es ist oft genauer als Random Forests, aber langsamer zu trainieren.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = GradientBoostingClassifier(n_estimators=100).fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))XGBoost / LightGBM
XGBoost und LightGBM sind optimierte Bibliotheken für Gradient Boosting – schneller, besser skalierbar und oft genauer als das GBM von sklearn.
# pip install xgboost lightgbm
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
xgb = XGBClassifier(n_estimators=100, eval_metric="logloss").fit(X_tr, y_tr)
print("XGB acc:", xgb.score(X_te, y_te))n_estimators abstimmen
Mehr Bäume in einem Random Forest reduzieren bis zu einem gewissen Punkt die Varianz, ohne zu Overfitting zu führen. Verwenden Sie eine Validierungskurve, um die optimale Anzahl zu ermitteln.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(random_state=0)
for n in [10, 50, 100, 200]:
scores = cross_val_score(RandomForestClassifier(n_estimators=n, random_state=0), X, y, cv=5)
print(f"n={n}: {scores.mean():.3f}")Einen Entscheidungsbaum visualisieren
Verwenden Sie sklearn.tree.plot_tree oder export_text, um zu untersuchen, was der Baum gelernt hat.
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=2).fit(X, y)
print(export_text(model, feature_names=load_iris().feature_names.tolist()))Kurze Überprüfung
Wie reduziert ein Random Forest im Vergleich zu einem einzelnen Entscheidungsbaum das Overfitting?
Zusammenfassung
Entscheidungsbäume teilen Daten anhand von Schwellenwerten der Merkmale auf und treffen Vorhersagen mit Blattwerten. Stimmen Sie max_depth ab, um Overfitting zu kontrollieren. Random Forests mitteln viele Bäume, um die Varianz zu reduzieren. Gradient Boosting trainiert Bäume nacheinander, um eine hohe Genauigkeit zu erreichen. Für den Produktionseinsatz sollten Sie XGBoost oder LightGBM bevorzugen.
Häufig gestellte Fragen
Ist die Lektion „Baumbasierte Modelle: Entscheidungsbäume und Random Forests“ kostenlos?
Ja — der vollständige Text von „Baumbasierte Modelle: Entscheidungsbäume und Random Forests“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Baumbasierte Modelle: Entscheidungsbäume und Random Forests“?
Erstellen und optimieren Sie Entscheidungsbaum- und Ensemble-Forest-Modelle. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Python Academy zu starten?
Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Baumbasierte Modelle: Entscheidungsbäume und Random Forests“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?
Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Die scikit-learn-API: fit, transform, predict
- Lineare Modelle: Regression und Klassifikation
- Baumbasierte Modelle: Entscheidungsbäume und Random Forests
- Modellbewertung und Kreuzvalidierung