Entscheidungsbäume: Theorie und Implementierung
Gini-Unreinheit, Informationsgewinn, Baumtiefe und Overfitting – sklearn DecisionTreeClassifier.
Entscheidungsbäume: Theorie und Implementierung ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 1 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 Learn AI with Python-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Entscheidungsbaum
Ein Entscheidungsbaum teilt die Daten anhand von Feature-Werten in Zweige auf. Dabei stellt er Ja/Nein-Fragen, bis er an einem Blattknoten eine Vorhersage trifft.
Jeder innere Knoten prüft ein Feature, jeder Zweig steht für ein Ergebnis, und jedes Blatt weist eine Klasse zu. Bäume sind leicht zu interpretieren, weil Sie dem Entscheidungsweg folgen können.
Gini-Unreinheit
Die Gini-Unreinheit misst, wie stark die Klassen in einem Knoten gemischt sind. Ein reiner Knoten, der nur eine Klasse enthält, hat den Gini-Wert 0.
Die Formel lautet Gini = 1 - sum(p_i^2), wobei p_i den Anteil der Klasse i angibt. Der Baum wählt die Aufteilungen, die die Unreinheit am stärksten reduzieren.
import numpy as np
def gini(labels):
classes, counts = np.unique(labels, return_counts=True)
probs = counts / counts.sum()
return 1 - np.sum(probs ** 2)
print(gini([0, 0, 1, 1])) # 0.5 (max mix)
print(gini([0, 0, 0, 0])) # 0.0 (pure)Informationsgewinn und Entropie
Ein alternatives Kriterium für Aufteilungen ist der Informationsgewinn, der auf der Entropie basiert. Die Entropie lautet -sum(p_i * log2(p_i)).
Informationsgewinn = Entropie(Elternknoten) - gewichtete Entropie(Kindknoten). Gini und Entropie erzeugen normalerweise ähnliche Bäume; Gini lässt sich etwas schneller berechnen.
import numpy as np
def entropy(labels):
_, counts = np.unique(labels, return_counts=True)
p = counts / counts.sum()
return -np.sum(p * np.log2(p))
print(entropy([0, 0, 1, 1])) # 1.0
print(entropy([0, 0, 0, 1])) # ~0.81DecisionTreeClassifier trainieren
Scikit-learn stellt DecisionTreeClassifier bereit. Mit dem Parameter criterion wählen Sie das Kriterium für die Aufteilung aus (gini oder entropy).
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, random_state=0)
clf = DecisionTreeClassifier(criterion="gini", random_state=0)
clf.fit(Xtr, ytr)
print("Accuracy:", clf.score(Xte, yte))Overfitting und max_depth
Ein unbeschränkter Baum wächst, bis jedes Blatt rein ist, und merkt sich dabei auch das Rauschen. Das führt zu Overfitting.
Der Parameter max_depth begrenzt die Tiefe des Baums und zwingt ihn dadurch zur Generalisierung. Geringere Tiefe = einfacheres Modell = weniger Overfitting.
from sklearn.tree import DecisionTreeClassifier
shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
deep = DecisionTreeClassifier(max_depth=None, random_state=0)
# shallow generalizes better on unseen data;
# deep often overfits the training setWeitere Parameter für Pre-Pruning
Neben max_depth können Sie das Wachstum mit folgenden Parametern steuern:
min_samples_splitMindestanzahl an Samples, um einen Knoten aufzuteilenmin_samples_leafMindestanzahl an Samples in einem Blattmax_leaf_nodesBegrenzung der Gesamtzahl an Blättern
Alle diese Parameter reduzieren die Varianz und wirken Overfitting entgegen.
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(
max_depth=5,
min_samples_split=10,
min_samples_leaf=5,
random_state=0,
)Visualisieren mit plot_tree
plot_tree zeichnet den vollständigen Baum, sodass Sie jede Aufteilung, den Gini-Wert und die Klassenverteilung an jedem Knoten ablesen können.
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
clf = DecisionTreeClassifier(max_depth=3).fit(X, y)
plt.figure(figsize=(12, 6))
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)
plt.show()Feature-Importances
Nach dem Training zeigt Ihnen feature_importances_, wie stark jedes Feature die Unreinheit über alle Aufteilungen hinweg reduziert hat. Die Werte summieren sich auf 1.0.
So können Sie schnell bestimmen, welche Eingaben für das Modell am wichtigsten sind.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
data = load_iris()
clf = DecisionTreeClassifier(max_depth=3).fit(data.data, data.target)
for name, imp in zip(data.feature_names, clf.feature_importances_):
print(f"{name}: {imp:.3f}")Cost-Complexity-Pruning (ccp_alpha)
Beim Post-Pruning wird zunächst ein vollständiger Baum erstellt und anschließend werden schwache Zweige entfernt. Der Parameter ccp_alpha steuert, wie stark beschnitten wird: Ein höherer Alpha-Wert entfernt mehr Knoten.
Verwenden Sie cost_complexity_pruning_path, um geeignete Alpha-Werte zu finden.
from sklearn.tree import DecisionTreeClassifier
base = DecisionTreeClassifier(random_state=0)
path = base.cost_complexity_pruning_path(Xtr, ytr)
alphas = path.ccp_alphas
pruned = DecisionTreeClassifier(ccp_alpha=0.01, random_state=0)
pruned.fit(Xtr, ytr)Den besten Alpha-Wert auswählen
Um ccp_alpha auszuwählen, trainieren Sie für jeden möglichen Alpha-Wert einen Baum und vergleichen dessen Validierungsgenauigkeit. Der beste Alpha-Wert stellt ein ausgewogenes Verhältnis zwischen Genauigkeit und Einfachheit her.
from sklearn.tree import DecisionTreeClassifier
scores = []
for a in alphas:
t = DecisionTreeClassifier(ccp_alpha=a, random_state=0)
t.fit(Xtr, ytr)
scores.append((a, t.score(Xte, yte)))
best = max(scores, key=lambda s: s[1])
print("Best alpha:", best[0])Stärken und Schwächen
Vorteile: gut interpretierbar, keine Skalierung erforderlich, verarbeitet nichtlineare Entscheidungsgrenzen und gemischte Datentypen.
Nachteile: hohe Varianz (kleine Änderungen an den Daten können den Baum stark verändern), anfällig für Overfitting, nur achsenparallele Aufteilungen. Diese Schwächen sind ein Grund für Ensemble-Methoden wie Random Forests.
Schnelltest
Testen Sie Ihr Verständnis der Konzepte rund um Entscheidungsbäume.
Rückblick
Rückblick: Entscheidungsbäume teilen Daten anhand der Gini-Unreinheit oder des Informationsgewinns auf. Begrenzen Sie Overfitting mit Pre-Pruning (max_depth, min_samples_leaf) oder Post-Pruning (ccp_alpha). Untersuchen Sie Modelle mit plot_tree und feature_importances_. Ihre hohe Varianz ist ein Grund für Ensemble-Methoden.
Häufig gestellte Fragen
Ist die Lektion „Entscheidungsbäume: Theorie und Implementierung“ kostenlos?
Ja — der vollständige Text von „Entscheidungsbäume: Theorie und Implementierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn AI with Python-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Entscheidungsbäume: Theorie und Implementierung“?
Gini-Unreinheit, Informationsgewinn, Baumtiefe und Overfitting – sklearn DecisionTreeClassifier. Du übst Learn AI with Python 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 Learn AI with Python zu starten?
Keine Vorkenntnisse erforderlich. Learn AI with Python 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 1 von 4.
Wie lange dauert die Lektion „Entscheidungsbäume: Theorie und Implementierung“?
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 Learn AI with Python-Lektion Code schreiben und ausführen?
Ja. Jede Learn AI with Python-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
- Entscheidungsbäume: Theorie und Implementierung
- Random Forests und Bagging
- Gradient Boosting: GBM und XGBoost
- LightGBM und CatBoost