Entscheidungsbäume erklärt: Wann klassisches ML besser ist als Deep Learning

Was ist ein Entscheidungsbaum in einem Satz?

Ein Entscheidungsbaum ist ein Modell, das eine Vorhersage durch eine Kette binärer Wenn-Dann-Fragen trifft — vom Wurzelknoten bis zum Blatt, das die Antwort liefert. Jeder innere Knoten prüft ein einzelnes Feature gegen einen Schwellwert („Einkommen > 30.000?”), jeder Zweig steht für das Ergebnis dieser Prüfung, und jedes Blatt liefert eine Klassenzuordnung oder einen Zahlenwert. Das macht den Baum zu einem der wenigen Modelle, dessen kompletter Entscheidungsweg sich auf eine Folie zeichnen lässt.

Genau diese Transparenz hat den Algorithmus seit den 1980er-Jahren in regulierten Branchen verankert: Banken nutzen Bäume für Credit-Scoring, Versicherungen für Tarif-Klassifikation, Pharma-Unternehmen für Diagnose-Workflows. Wer einer Aufsichtsbehörde erklären muss, warum ein Kreditantrag abgelehnt wurde, kann mit einer Baum-Skizze argumentieren — bei einem neuronalen Netz fällt das deutlich schwerer.

Der historische Stammbaum ist kurz: CART (Classification and Regression Trees, Breiman et al. 1984), ID3 und C4.5 (Quinlan, 1986/1993) sind die Klassiker. scikit-learn implementiert eine CART-Variante. Die wirkliche Renaissance kam aber nicht durch den Einzelbaum, sondern durch die Ensembles, die ab Mitte der 2000er-Jahre Standard wurden — dazu gleich mehr.

Die Algorithmen-Familie im Überblick

Die Baum-Welt teilt sich in fünf produktive Varianten. Wer diese kennt, deckt 95 % aller realen Anwendungsfälle ab — vom Einzelmodell für Lehrmaterial bis zum Production-Stack der Kaggle-Großmeister:innen.

Algorithmus	Trainings-Zeit (100k × 50)	Interpretierbarkeit	Typische Genauigkeit	Wann nutzen
Single Decision Tree	< 1 s (CPU)	★★★★★ — Pfad zeichenbar	★★☆☆☆	Lehrmaterial, sehr kleine Datensätze, regulierte Erklärbarkeit
Random Forest	5–30 s (CPU, n_jobs=−1)	★★★☆☆ — Feature-Importance, kein Pfad	★★★★☆	Robuster Default für Tabellen, geringes Hyperparameter-Tuning nötig
XGBoost	10–30 s (CPU)	★★★☆☆ — gain/weight/cover, SHAP populär	★★★★★	Production-Default für Kaggle und Business, kleine bis mittlere Datensätze
LightGBM	3–10 s (CPU), oft 2–10× schneller als XGBoost	★★★☆☆ — analog XGBoost	★★★★★	Sehr große Datensätze (>1 Mio. Zeilen), Speed-Priorität
CatBoost	15–40 s (CPU)	★★★★☆ — beste Default-Erklärbarkeit der Boosting-Familie	★★★★★	Viele kategorische Features ohne One-Hot-Encoding

Die Genauigkeits-Unterschiede zwischen den drei Boosting-Bibliotheken sind in der Praxis klein — auf den meisten Datensätzen entscheiden Hyperparameter-Tuning und Feature-Engineering mehr als die Wahl XGBoost vs. LightGBM. Wichtiger ist die strukturelle Frage: Brauche ich überhaupt ein Boosting-Modell, oder reicht ein Random Forest?

Wie wird ein Entscheidungsbaum gebaut? (Gini, Entropie)

Der Bau eines Baums folgt einem gierigen Algorithmus: An jedem Knoten wählt das Verfahren genau das Feature und den Schwellwert, die die Trainings-Daten am saubersten in zwei Gruppen trennen. „Sauber” misst man über eine Unreinheits-Metrik — typisch sind Gini-Index und Entropie.

Gini-Index misst die Wahrscheinlichkeit, dass ein zufällig gezogenes Element falsch klassifiziert würde, wenn man es nach der Klassenverteilung im Knoten labelt. Ein Knoten mit nur einer Klasse hat Gini = 0 (perfekt rein), ein Knoten mit 50/50-Verteilung in einem Zwei-Klassen-Problem hat Gini = 0,5 (maximale Unreinheit). scikit-learn nutzt Gini als Default — er ist rechnerisch billiger als Entropie und liefert in der Praxis fast identische Bäume.

Entropie kommt aus der Informationstheorie und misst die durchschnittlich benötigte Bit-Zahl, um die Klasse eines Elements zu kodieren. Mathematisch leicht teurer (Logarithmus statt Quadrat), aber theoretisch besser begründet. Wer es ausprobieren will: criterion='entropy' in scikit-learn. In 99 % der Fälle ist der Genauigkeits-Unterschied vernachlässigbar.

Der Algorithmus läuft so: Probiere für jedes Feature jeden möglichen Split-Punkt, berechne den Information Gain (Unreinheit vorher minus gewichtete Unreinheit nachher), wähle den besten. Wiederhole rekursiv für die entstandenen Teilmengen — bis ein Abbruchkriterium greift (max_depth erreicht, min_samples_leaf unterschritten, keine Verbesserung mehr möglich). Genau diese Gier ist der Grund, warum ein einzelner Baum so leicht overfittet: Ohne Beschränkung baut der Algorithmus den Datensatz Punkt für Punkt nach.

Konkretes Beispiel. Du willst Kredit-Anträge in „bewilligt” / „abgelehnt” klassifizieren. Der erste Split fragt vielleicht „Einkommen > 35.000 €?”. Im Ja-Zweig sind 80 % bewilligt, 20 % abgelehnt — Gini = 0,32. Im Nein-Zweig: 30 % bewilligt, 70 % abgelehnt — Gini = 0,42. Gewichtet ergibt das eine niedrigere Unreinheit als jeder andere mögliche Split — also wird das Feature gewählt. Dann geht es im Ja-Zweig weiter („Schufa-Score > 95?”), bis jeder Endknoten klar dominiert ist.

Was sind die Vor- und Nachteile gegenüber Deep Learning?

Bäume und neuronale Netze sind keine Konkurrenten — sie lösen unterschiedliche Datenformen. Wer beide Werkzeuge im Kopf hat, wählt das richtige für jede Aufgabe. Hier die ehrliche Inventur, ohne Hype für eine Seite.

Stärken von Baum-Verfahren:

• Tabellen-Default. Auf Daten mit klaren Spalten — Banking, CRM, Telco, IoT-Sensoren, klinische Studien — sind Gradient-Boosting-Bäume in praktisch jeder Benchmark die erste Wahl. Studien wie „Tabular Data: Deep Learning is Not All You Need” (Shwartz-Ziv & Armon, 2022) zeigen das systematisch.
• Keine GPU nötig. Ein normaler Laptop reicht. Während ein Transformer ohne CUDA-Karte unbenutzbar wäre, trainiert XGBoost 100k Zeilen in 10 Sekunden auf einer CPU.
• Robust gegen Skalierung. Bäume sind invariant gegen monotone Transformationen — du musst keine StandardScaler-Pipeline aufsetzen.
• Robust gegen Ausreißer. Ein einzelner extremer Wert verschiebt das Optimum nicht so stark wie bei linearen oder neuronalen Modellen.
• Eingebaute Feature-Importance. Du siehst out-of-the-box, welche Features wichtig waren — ein zentraler Vorteil in regulierten Domänen.
• Wenig Daten nötig. Random Forests liefern bereits ab ~1.000 Zeilen brauchbare Modelle. Deep Learning wird unter 100.000 Zeilen oft schlechter als ein gutes Baum-Modell.

Stärken von Deep Learning:

• Unstrukturierte Daten. Bilder, Audio, Video, Rohtext — hier bauen neuronale Netze eigenständig Repräsentationen, die kein manuelles Feature-Engineering je nachgebaut bekäme. Ein Decision Tree mit Pixeln als Spalten ist hoffnungslos.
• End-to-End-Lernen. Statt 80 % der Projektzeit in Feature-Engineering zu stecken, lernen tiefe Netze direkt aus Rohdaten. Bei Transformern gilt das auch für Text.
• Sehr große Datensätze. Ab ~10 Mio. Zeilen oder komplexen Feature-Interaktionen können tiefe Netze gleichziehen oder überholen.
• Multimodale Aufgaben. Bild + Text + Tabular gemeinsam — Bäume können das nicht in einem Modell.

Kriterium	Baum-Familie	Deep Learning
Datenform	Tabellarisch	Bilder, Text, Audio, Multimodal
Datenmenge	ab ~1.000 Zeilen	ab ~100.000 Beispielen
Hardware	CPU reicht	GPU/TPU faktisch Pflicht
Trainings-Zeit	Sekunden bis Minuten	Stunden bis Wochen
Interpretierbarkeit	Direkt	Nur über SHAP, LIME, Attention Maps
Hyperparameter-Tuning	Wenig nötig	Aufwändig, sensitiv
Energiekosten	Niedrig	Hoch

Was ist Random Forest und warum funktioniert es so gut?

Random Forest ist ein Ensemble aus typischerweise 100–500 Entscheidungsbäumen, die unabhängig voneinander auf zufälligen Stichproben der Trainingsdaten und der Features trainiert werden — die finale Vorhersage entsteht per Voting oder Mittelwert. Erfunden hat das Verfahren Leo Breiman 2001. Es ist bis heute einer der robustesten Out-of-the-Box-Algorithmen für strukturierte Daten.

Das Prinzip dahinter heißt Bagging (Bootstrap Aggregating). Aus den N Trainings-Zeilen werden N Zeilen mit Zurücklegen gezogen — jeder Baum sieht also rund 63 % der Originaldaten, einige Zeilen mehrfach, andere gar nicht. Zusätzlich darf jeder Baum an jedem Split nur einen zufälligen Teil der Features berücksichtigen (Default: √n_features bei Klassifikation). Diese doppelte Zufälligkeit entkoppelt die Bäume — und genau das ist der Trick: 500 leicht unterschiedliche, jeweils mittelmäßige Bäume mitteln sich zu einem sehr stabilen Gesamtmodell.

Warum das wirkt: Ein einzelner Baum hat hohe Varianz — kleine Änderungen im Trainingssatz führen zu völlig anderen Bäumen. Bagging reduziert genau diese Varianz, ohne den Bias zu erhöhen. Mathematisch beweisbar, empirisch in tausenden Benchmarks bestätigt.

Typische Hyperparameter im Random Forest:

• n_estimators (Anzahl Bäume): 100–500. Mehr schadet selten — kostet aber Speicher.
• max_depth (Maximale Tiefe pro Baum): 10–20, oder None für unbegrenzt.
• min_samples_leaf (Mindest-Größe eines Blattes): 1–20. Größere Werte = stärker regularisiert.
• max_features (Features pro Split): 'sqrt' ist Default für Klassifikation, 'log2' eine Alternative.
• n_jobs=-1 (Parallelisierung): nutzt alle CPU-Kerne.

Random Forest ist in der Praxis der ideale Start: wenig Tuning nötig, schwer kaputtzukriegen, vernünftige Genauigkeit auf fast jedem Tabellen-Datensatz. Wer mehr will, geht zu Gradient Boosting.

Wofür stehen XGBoost und LightGBM 2026?

Gradient Boosting baut Bäume sequenziell: Jeder neue Baum lernt die Fehler seiner Vorgänger zu korrigieren. Statt 500 unabhängiger Schätzer wie im Random Forest entsteht eine additive Reihe, deren einzelne Glieder klein und flach sind (typisch max_depth=6) — die Stärke kommt aus der schieren Anzahl und der Spezialisierung auf die Restfehler.

XGBoost (Tianqi Chen & Carlos Guestrin, Paper 2014) brachte mehrere Innovationen, die Gradient Boosting industrialisiert haben: regulierte Loss-Funktion (L1 + L2), effizienter Histogram-basierter Split, paralleles Training auf CPU-Kernen, sparse-aware-Splits für fehlende Werte. Seit 2014 dominiert XGBoost die Kaggle-Wettbewerbe auf strukturierten Daten — und ist in Banken, E-Commerce und Telco der Production-Default.

LightGBM (Microsoft Research, 2017) optimierte XGBoost in zwei Richtungen: leaf-wise Wachstum (immer das Blatt mit dem größten Loss-Gain expandieren statt schichtweise) und histogrammbasierte Feature-Binning. Resultat: 2–10× schneller auf großen Datensätzen, deutlich weniger Speicher. Für Daten über 1 Mio. Zeilen ist LightGBM oft die pragmatische Wahl. Achtung: Auf kleinen Datensätzen (< 10.000 Zeilen) kann leaf-wise Wachstum overfitten — dort bleibt XGBoost robuster.

CatBoost (Yandex, 2017) ist die dritte produktive Variante. Spezialität: native Behandlung kategorischer Features ohne vorgeschaltetes One-Hot-Encoding, plus geringeres Overfitting-Risiko dank Ordered Boosting. Für Datensätze mit vielen kategorischen Spalten — z. B. Werbe-Daten mit User-IDs, Geräte-Klassen, Ländern — oft die beste Out-of-the-Box-Genauigkeit.

Vergleichs-Achse	XGBoost 2.0+	LightGBM 4+	CatBoost 1.2+
Erscheinungsjahr	2014	2017	2017
Wachstums-Strategie	level-wise	leaf-wise	symmetric (Oblivious Trees)
Speed auf 1 Mio. Zeilen	Basis	2–10× schneller	~1,5× schneller als XGBoost
Kategorische Features	One-Hot nötig	One-Hot empfohlen	Nativ (Ziel-Encoding eingebaut)
GPU-Support	Ja (device='cuda')	Ja (device='gpu')	Ja
Default-Performance	Top auf kleinen + mittleren Daten	Top auf großen Daten	Top bei vielen Kategorien
Community-Größe	Größte	Sehr groß	Mittel

Auf Kaggle gewinnen seit 2015 nahezu alle Tabular-Wettbewerbe Lösungen auf Basis von XGBoost, LightGBM oder CatBoost — oft als Ensemble der drei. Wer in einem realen Business-Projekt einen Tabular-Klassifikator braucht, kommt um diese drei Bibliotheken nicht herum.

Wann sollte ich Bäume statt neuronaler Netze nutzen?

Die Entscheidungsfrage ist nicht „besser oder schlechter”, sondern „passt das Werkzeug zum Datenformat”. Eine pragmatische Heuristik:

Nimm Bäume, wenn:

• Deine Daten tabellarisch sind und unter ~10 Mio. Zeilen haben.
• Du Erklärbarkeit brauchst — Kredit, Versicherung, Medizin, Justiz, HR.
• Du schnelle Iteration willst (Training in Sekunden, nicht Tagen).
• Du keine GPU-Infrastruktur hast oder aufbauen willst.
• Du eine starke Baseline suchst, bevor du in Deep Learning investierst.
• Du wenige Daten hast (1.000–50.000 Zeilen).

Nimm Deep Learning, wenn:

• Deine Daten unstrukturiert sind (Bilder, Audio, Video, Rohtext).
• Du sehr viele Daten hast (100.000+ Beispiele bei Bildern, Millionen bei Text).
• Du auf multimodale Aufgaben zielst (Bild + Text + Tabular).
• State-of-the-art-Performance geschäftskritisch ist und du das Budget für GPUs und Training-Runs hast.
• Du Transfer Learning auf vortrainierte Modelle nutzen kannst (Hugging Face, OpenCV-Zoo).

Für den vollständigen Vergleich Klassisches ML vs. Deep Learning siehe die Sektionen im übergeordneten Pillar Maschinelles Lernen und im Hub Deep Learning.

Wie sieht der Code aus? (Python + scikit-learn, 10 Zeilen)

Ein vollständiges Random-Forest-Training in zehn Zeilen produktivem Python. Funktioniert mit jedem CSV, das eine Zielspalte und numerische Features hat. scikit-learn 1.4+ ist Standard seit Jahren — die API hat sich seit 2017 kaum verändert.

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

df = pd.read_csv("data.csv")
X, y = df.drop("target", axis=1), df["target"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)

model = RandomForestClassifier(n_estimators=500, max_depth=10, n_jobs=-1, random_state=42)
model.fit(X_train, y_train)

preds = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, preds):.3f}")
print(sorted(zip(model.feature_importances_, X.columns), reverse=True)[:5])

Was passiert hier Zeile für Zeile:

1–4. Imports: pandas für das Einlesen, RandomForestClassifier als Modell, train_test_split für die Aufteilung, accuracy_score zur Bewertung. 5–7. CSV laden, Features (X) und Ziel (y) trennen, in Trainings- und Test-Set splitten. stratify=y sorgt für balancierte Klassenverteilung, random_state=42 macht das Ergebnis reproduzierbar. 9. Modell instanziieren: 500 Bäume, maximale Tiefe 10, alle CPU-Kerne nutzen. 10. Training — auf 100k Zeilen × 50 Features dauert das auf einem normalen Laptop unter einer Minute. 12–13. Vorhersagen für den Test-Set, Accuracy berechnen, Top-5-Features nach Importance ausgeben.

Für XGBoost statt Random Forest: ersetze die Zeilen 2 und 9 durch:

from xgboost import XGBClassifier
model = XGBClassifier(n_estimators=500, max_depth=6, learning_rate=0.05, n_jobs=-1, random_state=42)

Genauigkeit meist 1–3 Prozentpunkte besser als Random Forest, Trainings-Zeit vergleichbar oder schneller. Für viele kategorische Features bietet sich CatBoost an, mit fast identischer API. Wer noch tiefer in den Tabular-ML-Stack will: Code-Assistenten wie GitHub Copilot oder Cursor generieren scikit-learn-Boilerplate in Sekunden — gerade beim Hyperparameter-Tuning hilft das.

Wie interpretiere ich Feature-Importance?

Feature-Importance ist ein Score pro Eingabe-Spalte, der ausdrückt, wie sehr ein Feature im Schnitt zur Trennung der Klassen beigetragen hat. scikit-learn liefert sie out-of-the-box über model.feature_importances_ — ein NumPy-Array, das zu deinen Spalten korrespondiert.

Wie der Score berechnet wird: Bei jedem Split eines Baumes wird festgehalten, wie stark die Unreinheit (Gini oder Entropie) durch genau diesen Split reduziert wird, gewichtet mit der Anzahl der Samples im Knoten. Diese „Mean Decrease in Impurity” wird über alle Bäume gemittelt und auf 1 normalisiert. Hohe Werte = wichtiges Feature. Aber: Der Score ist sensitiv gegen Skala — Features mit vielen unterschiedlichen Werten (z. B. fortlaufende IDs) bekommen automatisch hohe Scores, obwohl sie inhaltlich nichts beitragen. Eine ID-Spalte solltest du also vor dem Training entfernen.

Drei produktive Alternativen für robustere Interpretation:

• Permutation Importance (sklearn.inspection.permutation_importance): Mischt eine Spalte zufällig durch und misst den Accuracy-Verlust. Robuster gegen Skalierungs-Artefakte. Kostet Rechenzeit, lohnt sich aber.
• SHAP (Shapley Additive Explanations, Lundberg & Lee 2017): Spielt jede Vorhersage durch alle Feature-Kombinationen und berechnet den Beitrag jedes Features mathematisch fair. Goldstandard in regulierten Branchen. Library: shap.
• XGBoost-eigene Metriken (gain, weight, cover): gain ist meist die aussagekräftigste — wie viel Verbesserung des Loss ein Feature im Schnitt brachte.

In regulierten Branchen ist Feature-Importance oft kein Nice-to-have, sondern Pflicht: Die BaFin verlangt von Banken nachvollziehbare Kredit-Entscheidungen, der EU AI Act stuft Hochrisiko-Systeme als erklärungspflichtig ein. Genau hier punkten Bäume: SHAP-Values lassen sich pro Einzelfall ausgeben — „Diese Ablehnung lag zu 40 % am Schufa-Score, zu 25 % am Beschäftigungs-Status, zu 15 % an der Wohndauer.” Bei einem tiefen neuronalen Netz wäre dieselbe Auskunft technisch möglich, aber teurer und weniger stabil.

Was sind die häufigsten Fehler beim Training?

Aus Hunderten Code-Reviews destilliert: Die fünf Stolperfallen, die Anfänger:innen wie Profis regelmäßig produzieren.

1. Data Leakage. Du nutzt versehentlich Features, die das Label „verraten” — z. B. ein Feld, das erst nach der Ziel-Entscheidung gefüllt wird. Symptom: Training-Accuracy 99 %, in Production stürzt das Modell ab. Gegenmittel: Pipeline strikt nach Zeitstempel sortieren, Features auf Plausibilität prüfen, mit fachlicher Domain-Expert:in durchgehen.

2. Falsche Behandlung von Test-Daten. Du fittest deinen Scaler/Imputer auf dem gesamten Datensatz und splittest erst danach. Resultat: Test-Daten haben Informationen aus dem Training „durchsickern” lassen. Korrekt: erst splitten, dann nur auf Trainings-Daten fitten und das gefittete Objekt auf Test-Daten anwenden. sklearn.pipeline.Pipeline zwingt dich dazu.

3. Unbalancierte Klassen ignorieren. Bei Fraud-Detection oder seltenen Krankheiten ist das Label-Verhältnis schnell 1:99. Ein Modell, das immer „kein Fraud” sagt, hat 99 % Accuracy — und ist nutzlos. Gegenmittel: class_weight='balanced' setzen, ROC-AUC oder F1 statt Accuracy als Metrik nutzen, oder zu spezialisierten Verfahren wie imbalanced-learn greifen.

4. Overfitting durch unbegrenzten Baum. Default-Einstellungen ohne max_depth und min_samples_leaf führen bei einem Einzelbaum schnell zu perfekter Trainings-Accuracy und schlechter Generalisierung. Faustregel für Random Forest: max_depth=10–20, min_samples_leaf=1–5. Für XGBoost: max_depth=4–8, learning_rate=0.01–0.1, early_stopping_rounds=50.

5. Hyperparameter ohne Cross-Validation. Ein einzelner Train/Test-Split kann zufällig glücklich liegen. Für saubere Hyperparameter-Suche GridSearchCV oder RandomizedSearchCV mit 5-facher Kreuzvalidierung — oder besser direkt optuna für Bayesian Optimization. Auf großen Datensätzen reicht oft ein einzelner Hold-out-Set, aber dann mindestens mit early_stopping.

Produktive Anwendungsfelder: Wo Bäume täglich entscheiden

Ein paar konkrete Beispiele aus der DACH-Praxis, damit der Abstraktionsgrad sinkt:

• Credit-Scoring (Banken, Sparkassen). Schufa-Score, Einkommen, Beschäftigungsdauer, Vor-Kredite — XGBoost-Modelle entscheiden Millionen Kreditanträge täglich. Erklärbarkeit ist BaFin-Pflicht, deshalb keine Deep-Learning-Black-Box.
• Churn-Prediction (Telcos, SaaS). Wer kündigt im nächsten Quartal? Random Forests mit Verhaltens-Features (Login-Frequenz, Support-Tickets, Vertrags-Alter) liefern brauchbare Wahrscheinlichkeiten — die Retention-Teams ihre Outreach planen lassen.
• Recommender-Pre-Filtering (E-Commerce). Bevor ein komplexer Embedding-Recommender 50.000 Produkte rankt, filtert ein LightGBM die Top-500 für den User. Faktor 100 Speed-Up bei vernachlässigbarem Genauigkeits-Verlust.
• Predictive Maintenance (Industrie 4.0). Sensordaten von Werkzeugmaschinen, Pumpen, Turbinen. Bäume erkennen Drift-Muster, bevor ein Bauteil ausfällt — Siemens, Bosch und SAP setzen das in Industrie-Pipelines ein.
• Insurance Pricing. Versicherungs-Tarife werden seit Jahrzehnten über Bäume klassifiziert — heute kommen Boosting-Modelle dazu, oft mit GLM-Ensemble für die Erklärbarkeits-Schicht.
• Fraud-Detection (Zahlungsverkehr). Jede Kartentransaktion wird in Millisekunden bewertet — XGBoost-Modelle entscheiden Anomalien gegen das normale Verhaltensprofil eines Karteninhabers.

In all diesen Fällen wäre Deep Learning technisch denkbar, in der Praxis aber unwirtschaftlich oder regulatorisch problematisch. Der Baum-Stack bleibt der pragmatische Default — und wird das auch 2030 noch sein, solange Business-Daten weiterhin in Zeilen und Spalten organisiert sind.

Vertiefe dein Wissen: Dein Weg durch klassisches ML

Dieser Hub steht zwischen Grundlagen und Vertiefung. Je nach Interesse geht es so weiter:

Grundlagen vertiefen

• Maschinelles Lernen — der Einsteiger-Pillar, der Bäume in den größeren ML-Kontext einordnet. · ~12 Min.
• Was ist KI? — der Rahmen, in dem Machine Learning steht. · ~10 Min.

Komplementäre Techniken

• Deep Learning & Neuronale Netze — wann tiefe Netze besser sind als Bäume. · ~12 Min.
• Neuronale Netze einfach erklärt — der Aufbau des Gegenstücks. · ~9 Min.
• Transformer-Architektur — die dominante Deep-Learning-Architektur 2026. · ~10 Min.

Praxis und Tools

• Code-Assistenten im Überblick — Cursor, GitHub Copilot & Co. generieren scikit-learn-Boilerplate in Sekunden.
• Prompt-Engineering — wie du LLMs als Pair-Programmer für ML-Workflows nutzt. · ~6 Min.
• RAG — Retrieval Augmented Generation — LLMs mit eigenen Tabellen-Daten verbinden. · ~8 Min.