A decision tree predicts by asking a chain of yes/no questions about features. The tool above shows one cut; a real tree stacks many of them, recursively splitting the data into ever-purer regions until each leaf hands back a prediction.
Where you meet it
- Classifiers and regressors in scikit-learn (
DecisionTreeClassifier), and the base learner inside Random Forests and gradient boosting (XGBoost, LightGBM). - Tabular ML — credit scoring, churn, medical triage — where you also need to explain the prediction.
- Feature importance: which columns actually drove the splits.
What it does
It learns a hierarchy of axis-parallel splits. Each internal node tests one feature against a threshold and routes the sample left or right; each leaf stores a prediction — the majority class (classification) or the mean (regression) of the training points that landed there. Prediction is just walking root-to-leaf.
A single tree is readable but jittery — change a few rows and it reshapes. That's exactly why we average a forest.
How it works
Growth is greedy and recursive. At each node the algorithm scans every feature and every candidate threshold, and picks the split that reduces impurity the most — the largest information gain:
gain = impurity(parent) − ( n_L/n · impurity(left) + n_R/n · impurity(right) )Impurity measures how mixed a node is. Two common choices for classification:
Gini = 1 − Σ pₖ²
Entropy = − Σ pₖ · log₂ pₖBoth are 0 for a pure node and peak when classes are balanced. One split, concretely: a parent with 7 A + 7 B has Gini 1 − 0.5² − 0.5² = 0.5. Split it into a 6A/1B leaf (≈ 0.24) and a 1A/6B leaf (≈ 0.24); the weighted child impurity is 0.24, so the gain is 0.5 − 0.24 = 0.26. The algorithm keeps the split with the biggest such drop, then recurses on each child — stopping when a node is pure, too small (min_samples_leaf), or hits max_depth.
Watch out
- Overfitting. Grown unrestricted, a tree memorises noise — perfect on train, poor on test. Limit depth, set
min_samples_leaf, or apply cost-complexity pruning (ccp_alpha). - Instability. A small change in the data can flip an early split and reshape the whole tree. Averaging many trees — a Random Forest — fixes this and is the usual reason single trees are rarely used alone.
- Imbalanced classes & biased splits. A dominant class can starve good splits; impurity criteria also favour features with many distinct values. Use class weights and watch the splitting metric.
- Axis-parallel only. Diagonal boundaries get approximated by a staircase of cuts — fine, but it costs depth.
Go deeper
Ein Entscheidungsbaum sagt vorher, indem er eine Kette von Ja/Nein-Fragen über Merkmale stellt. Das Tool oben zeigt einen Schnitt; ein echter Baum stapelt viele davon und teilt die Daten rekursiv in immer reinere Bereiche, bis jedes Blatt eine Vorhersage liefert.
Wo es vorkommt
- Klassifikatoren und Regressoren in scikit-learn (
DecisionTreeClassifier) und als Basislerner in Random Forests und Gradient Boosting (XGBoost, LightGBM). - Tabellen-ML — Kreditscoring, Churn, medizinische Triage — wo die Vorhersage auch erklärbar sein muss.
- Feature Importance: welche Spalten die Splits tatsächlich getrieben haben.
Was es tut
Er lernt eine Hierarchie aus achsenparallelen Splits. Jeder innere Knoten testet ein Merkmal gegen eine Schwelle und schickt das Sample links oder rechts; jedes Blatt speichert eine Vorhersage — die Mehrheitsklasse (Klassifikation) oder den Mittelwert (Regression) der dort gelandeten Trainingspunkte. Vorhersagen heißt: von der Wurzel zum Blatt laufen.
Ein einzelner Baum ist lesbar, aber nervös — ein paar Zeilen anders und er formt sich um. Genau darum mittelt man einen Forest.
Wie es funktioniert
Das Wachsen ist gierig und rekursiv. An jedem Knoten prüft der Algorithmus jedes Merkmal und jede mögliche Schwelle und wählt den Split, der die Unreinheit am stärksten senkt — den größten Information Gain:
Gewinn = Unreinheit(Eltern) − ( n_L/n · Unreinheit(links) + n_R/n · Unreinheit(rechts) )Die Unreinheit misst, wie gemischt ein Knoten ist. Zwei gängige Maße für die Klassifikation:
Gini = 1 − Σ pₖ²
Entropie = − Σ pₖ · log₂ pₖBeide sind 0 für einen reinen Knoten und maximal bei ausgeglichenen Klassen. Ein Split, konkret: Ein Elternknoten mit 7 A + 7 B hat Gini 1 − 0,5² − 0,5² = 0,5. Teilt man ihn in ein 6A/1B-Blatt (≈ 0,24) und ein 1A/6B-Blatt (≈ 0,24), beträgt die gewichtete Kind-Unreinheit 0,24 — der Gewinn also 0,5 − 0,24 = 0,26. Der Algorithmus behält den Split mit dem größten Rückgang und rekursiert auf jedem Kind — Stopp, sobald ein Knoten rein ist, zu klein wird (min_samples_leaf) oder max_depth erreicht.
Worauf achten
- Überanpassung. Ohne Grenzen lernt ein Baum das Rauschen auswendig — perfekt auf Training, schwach im Test. Tiefe begrenzen,
min_samples_leafsetzen oder Cost-Complexity-Pruning (ccp_alpha) nutzen. - Instabilität. Eine kleine Datenänderung kann einen frühen Split kippen und den ganzen Baum umformen. Das Mitteln vieler Bäume — ein Random Forest — behebt das und ist der übliche Grund, warum einzelne Bäume selten allein laufen.
- Unbalancierte Klassen & verzerrte Splits. Eine dominante Klasse kann gute Splits ausbremsen; Unreinheitsmaße bevorzugen zudem Merkmale mit vielen verschiedenen Werten. Klassengewichte setzen und die Split-Metrik im Blick behalten.
- Nur achsenparallel. Diagonale Grenzen werden durch eine Treppe aus Schnitten angenähert — geht, kostet aber Tiefe.