Entscheidungsbäume: KI-Modelle, die mit Ja/Nein-Fragen arbeiten

Entscheidungsbäume sind eines der intuitivsten Modelle der künstlichen Intelligenz. Sie funktionieren wie ein interaktives Ratespiel: Statt zu raten, stellen sie systematische Ja/Nein-Fragen, um eine Klasse oder einen Wert vorherzusagen. Doch wie lernt ein Entscheidungsbaum, welche Fragen er stellen muss? Und warum gilt er als besonders transparent?

Diese Anleitung erklärt Schritt für Schritt, wie Entscheidungsbäume aufgebaut sind, wie sie Entscheidungen treffen und wie Sie sie mit Python trainieren können – ohne komplizierte Mathematik.

Wie ein Entscheidungsbaum funktioniert: Ein Beispiel aus dem Alltag

Stellen Sie sich vor, Sie möchten vorhersagen, ob ein Kunde ein Produkt kauft, basierend auf Alter und Einkommen. Ein Entscheidungsbaum könnte folgende Logik entwickeln:

• Hat der Kunde ein Einkommen über 50.000 €?
• Ja:
• Ist er älter als 30 Jahre?
• Ja: Kunde wird kaufen.
• Nein: Kunde wird nicht kaufen.
• Nein: Kunde wird nicht kaufen.

Jeder Knoten im Baum repräsentiert eine Frage, jede Kante eine mögliche Antwort und die Endknoten (Blätter) die finale Vorhersage. Um eine neue Vorhersage zu treffen, durchläuft der Algorithmus den Baum von der Wurzel bis zu einem Blatt – immer der Antwort entsprechend.

Die Mathematik hinter den Entscheidungen: Entropie und Informationsgewinn

Ein Entscheidungsbaum wählt nicht zufällig Fragen aus. Stattdessen sucht er nach der Frage, die die Daten am besten in reine Gruppen aufteilt. Zwei Konzepte sind hier entscheidend:

• Entropie: Misst die Unordnung in einer Gruppe. Eine Entropie von 0 bedeutet, dass alle Beispiele zur gleichen Klasse gehören – das Modell ist sich sicher. Eine Entropie von 1 zeigt eine gleichmäßige Verteilung zwischen zwei Klassen an.

import numpy as np

def entropy(p):
    # p = Anteil der positiven Klasse
    if p == 0 or p == 1:
        return 0  # Reine Gruppe, keine Unsicherheit
    return -p * np.log2(p) - (1 - p) * np.log2(1 - p)

• Informationsgewinn: Dieser Wert gibt an, wie stark eine Frage die Entropie reduziert. Der Baum wählt die Frage mit dem höchsten Informationsgewinn, um die Daten in möglichst reine Untergruppen zu teilen.

def information_gain(parent_entropy, left_group, right_group):
    n_left = len(left_group)
    n_right = len(right_group)
    n_total = n_left + n_right
    p_left = sum(left_group) / n_left if n_left > 0 else 0
    p_right = sum(right_group) / n_right if n_right > 0 else 0
    weighted_entropy = (
        (n_left / n_total) * entropy(p_left) +
        (n_right / n_total) * entropy(p_right)
    )
    return parent_entropy - weighted_entropy

Ein einfaches Beispiel: Angenommen, Sie haben 10 Beispiele mit je fünf positiven und fünf negativen Klassen. Eine perfekte Aufteilung in zwei reine Gruppen würde einen Informationsgewinn von 1,0 erzielen – das ist der höchste mögliche Wert.

Einen Entscheidungsbaum mit scikit-learn trainieren

Die Bibliothek scikit-learn bietet eine einfache Möglichkeit, Entscheidungsbäume zu trainieren. Hier ein Schritt-für-Schritt-Beispiel mit dem Iris-Datensatz:

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Daten laden und aufteilen
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Modell trainieren
baum = DecisionTreeClassifier(max_depth=3, random_state=42)
baum.fit(X_train, y_train)

# Vorhersagen treffen
y_pred = baum.predict(X_test)
print(f"Genauigkeit: {accuracy_score(y_test, y_pred):.3f}")  # Ausgabe: 0.967

Das trainierte Modell kann nun als Textbaum ausgegeben werden, um die Entscheidungsregeln nachzuvollziehen:

regeln = export_text(baum, feature_names=iris.feature_names)
print(regeln)

Die Ausgabe zeigt eine klare Hierarchie:

• Ist die Kelchblattlänge ≤ 2,45 cm?
• Ja: Klasse ist setosa.
• Nein:
• Ist die Kronblattbreite ≤ 1,75 cm?
• Ja:
• Ist die Kelchblattlänge ≤ 4,95 cm?
• Ja: Klasse ist versicolor.
• Nein: Klasse ist virginica.
• Nein: Klasse ist virginica.

Diese Struktur macht Entscheidungsbäume besonders wertvoll in Anwendungen, bei denen Nachvollziehbarkeit entscheidend ist.

Überanpassung vermeiden: Wie Sie die Leistung Ihres Baums steuern

Entscheidungsbäume neigen dazu, sich zu sehr an die Trainingsdaten anzupassen. Um dies zu verhindern, können Sie folgende Parameter anpassen:

• max_depth: Begrenzt die Tiefe des Baums, um zu komplexe Strukturen zu vermeiden.
• min_samples_split: Legt fest, wie viele Beispiele mindestens in einem Knoten vorhanden sein müssen, um weiter aufgeteilt zu werden.
• min_samples_leaf: Bestimmt die minimale Anzahl von Beispielen in einem Blatt.

baum = DecisionTreeClassifier(
    max_depth=5,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=42
)

Zusätzlich können Sie die Feature-Bedeutung auslesen, um zu verstehen, welche Variablen den größten Einfluss auf die Vorhersage haben:

print("Feature-Bedeutung:")
for name, wert in zip(iris.feature_names, baum.feature_importances_):
    print(f"{name}: {wert:.3f}")

Visualisierung: Den Baum grafisch darstellen

Eine grafische Darstellung hilft, die Struktur des Baums zu verstehen. Mit scikit-learn und Matplotlib können Sie den Baum visualisieren:

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(15, 6))
plot_tree(
    baum,
    feature_names=iris.feature_names,
    class_names=iris.target_names,
    filled=True,
    rounded=True,
    fontsize=10
)
plt.title("Entscheidungsbaum – Iris-Datensatz (max_depth=3)")
plt.show()

Die Visualisierung zeigt die hierarchische Struktur des Baums mit farblich markierten Blättern, die die dominierende Klasse anzeigen.

Fazit: Entscheidungsbäume für klare und nachvollziehbare KI

Entscheidungsbäume kombinieren Einfachheit mit hoher Leistung und bieten dabei volle Transparenz. Sie eignen sich besonders für Anwendungen, bei denen Entscheidungen nachvollziehbar sein müssen – sei es in der Medizin, im Finanzwesen oder im Kundenservice.

Mit Bibliotheken wie scikit-learn lassen sich Entscheidungsbäume schnell trainieren und anpassen. Durch die Kontrolle von Parametern wie Tiefe oder Mindestbeispielanzahl vermeiden Sie Überanpassung und erhalten robuste Modelle. Wer KI verstehen will, ohne sich in komplexen Algorithmen zu verlieren, findet in Entscheidungsbäumen ein mächtiges Werkzeug.