Machine-Learning-Algorithmen erklärt: Der vollständige Leitfaden für technische Interviews

Machine-Learning-Algorithmen bilden das Fundament jedes technischen Vorstellungsgesprächs im Bereich Data Science. Ob die ausgeschriebene Stelle auf einen Junior Data Scientist oder einen Senior ML Engineer abzielt – Interviewende erwarten von Kandidatinnen und Kandidaten, dass sie die zentralen Algorithmusfamilien erklären, implementieren und miteinander vergleichen können. Der vorliegende Leitfaden behandelt jede wesentliche Algorithmus-Kategorie mit Python-Implementierungen unter Verwendung von scikit-learn 1.8, bewährten Evaluierungsstrategien sowie den Abwägungen, die starke Kandidaten von schwächeren unterscheiden. Das Ziel ist nicht eine oberflächliche Auflistung von Algorithmen, sondern ein tiefes Verständnis der Konzepte dahinter – das, was Einstellungsteams wirklich suchen.

Überwachtes Lernen: Grundlagen von Regression und Klassifikation

Algorithmen des überwachten Lernens lernen aus beschrifteten Daten – jedes Trainingsbeispiel enthält eine Eingabe sowie die erwartete Ausgabe. Regression sagt kontinuierliche Werte vorher (Hauspreise, Temperaturen), während Klassifikation diskrete Bezeichnungen zuweist (Spam/kein Spam, Krankheitsdiagnose). Das Verständnis beider Ansätze ist in Data-Science-Interviews unverzichtbar.

Die lineare Regression ist der Ausgangspunkt für jede Regressionsaufgabe. Sie modelliert die Beziehung zwischen Merkmalen und einer Zielvariablen als gewichtete Summe. Mathematisch gesprochen minimiert die Methode die Summe der quadrierten Residuen – die Differenzen zwischen vorhergesagten und tatsächlichen Werten. In Interviews werden Kandidatinnen und Kandidaten häufig gebeten, die Methode zu implementieren, die Kostenfunktion zu erläutern und zu erklären, in welchen Situationen das Modell an Grenzen stößt. Zu den typischen Schwächen gehören Nichtlinearität der Zielfunktion, Multikollinearität zwischen Merkmalen sowie Ausreißer im Datensatz, die den Koeffizientenschätzer verzerren.

# linear_regression_demo.py
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Generate synthetic housing data: square footage -> price
np.random.seed(42)
sqft = np.random.uniform(500, 3000, size=200).reshape(-1, 1)
price = 150 * sqft.flatten() + np.random.normal(0, 20000, size=200)

X_train, X_test, y_train, y_test = train_test_split(sqft, price, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)                    # Fit on training data
predictions = model.predict(X_test)            # Predict on unseen data

print(f"Coefficient: {model.coef_[0]:.2f}")    # Weight per sqft
print(f"R2 Score: {r2_score(y_test, predictions):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, predictions)):.2f}")

Der Koeffizient zeigt, wie stark jeder zusätzliche Quadratmeter zum Preis beiträgt. Der R2-Score und der RMSE quantifizieren die Vorhersagequalität – zwei Kennzahlen, die Interviewer ohne Zögern interpretiert sehen möchten. Ein R2 nahe 1,0 deutet auf eine starke Erklärungskraft des Modells hin, während ein hoher RMSE absolute Abweichungen in der Einheit der Zielvariable beschreibt.

Für die Klassifikation wendet die logistische Regression eine Sigmoid-Funktion an, um Wahrscheinlichkeiten zu berechnen. Trotz ihres Namens löst sie Klassifikationsprobleme. Die Entscheidungsgrenze liegt standardmäßig bei 0,5, lässt sich aber anpassen – ein wichtiger Hinweis bei unausgewogenen Datensätzen. Der Regularisierungsparameter C sowie die Unterschiede zwischen binären und Mehrklassen-Einstellungen (One-vs-Rest vs. Softmax) sind häufige Interviewthemen, die über das reine Ausführen von Code hinausgehen.

# logistic_classification.py
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

data = load_breast_cancer()                    # Binary classification dataset
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

clf = LogisticRegression(max_iter=5000, C=1.0) # C controls regularization strength
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred, target_names=data.target_names))

Der Klassifikationsbericht zeigt Precision, Recall und F1-Score je Klasse – genau die Metriken, die im folgenden Abschnitt behandelt werden. Es empfiehlt sich, diese Berichte flüssig lesen zu können; Interviewer bemerken sofort, wenn Kandidatinnen und Kandidaten bei der Interpretation ins Stocken geraten. Besonders bei medizinischen oder sicherheitskritischen Anwendungen ist das Verhältnis zwischen Precision und Recall keine akademische Frage, sondern eine mit realen Konsequenzen.

Entscheidungsbäume und Ensemble-Methoden, die Interviews dominieren

Entscheidungsbäume teilen Daten rekursiv anhand von Merkmalsschwellenwerten auf. Jede Teilung wählt das Merkmal und den Schwellenwert, der den Informationsgewinn maximiert oder die Gini-Unreinheit minimiert. Einzeln eingesetzt neigen sie zum Overfitting – ein tiefer Baum kann Trainingsdaten nahezu perfekt abbilden, generalisiert aber schlecht auf neue Beispiele. Ensemble-Methoden – Random Forest und Gradient Boosting – lösen dieses Problem, indem sie mehrere Bäume kombinieren. Diese Algorithmen tauchen in nahezu jedem ML-Interview auf, da sie Interpretierbarkeit mit hoher Leistungsfähigkeit verbinden.

Random Forest baut viele unabhängige Bäume auf Bootstrap-Stichproben auf und mittelt deren Vorhersagen. Dadurch wird die Varianz reduziert, ohne den Bias zu erhöhen. Jeder Baum sieht zudem nur eine zufällig gewählte Teilmenge der Merkmale bei jeder Teilungsentscheidung – das erzeugt Diversität unter den Bäumen und ist der Schlüssel zum Erfolg des Verfahrens.

# ensemble_comparison.py
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score

data = load_wine()                             # 3-class classification
X, y = data.data, data.target

# Random Forest: parallel trees, reduces variance
rf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
rf_scores = cross_val_score(rf, X, y, cv=5, scoring='accuracy')

# Gradient Boosting: sequential trees, reduces bias
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)
gb_scores = cross_val_score(gb, X, y, cv=5, scoring='accuracy')

print(f"Random Forest:     {rf_scores.mean():.4f} +/- {rf_scores.std():.4f}")
print(f"Gradient Boosting: {gb_scores.mean():.4f} +/- {gb_scores.std():.4f}")

Random Forest eignet sich besonders dann, wenn Stabilität und geringer Abstimmungsaufwand im Vordergrund stehen. Gradient Boosting erzielt häufig eine höhere Genauigkeit, erfordert jedoch eine sorgfältige Hyperparameter-Auswahl – Lernrate, Anzahl der Schätzer und Baumtiefe interagieren miteinander. Interviewer testen, ob Kandidatinnen und Kandidaten diesen Kompromiss verstehen, nicht nur welche Zahl größer ist. Gradient Boosting lernt sequenziell: Jeder neue Baum korrigiert die Fehler aller vorherigen Bäume, indem er auf die negativen Gradienten der Verlustfunktion trainiert wird.

| Kriterium | Random Forest | Gradient Boosting | |-----------|--------------|-------------------| | Trainingsgeschwindigkeit | Schnell (parallel) | Langsamer (sequenziell) | | Overfitting-Risiko | Gering | Höher ohne Tuning | | Hyperparameter-Sensitivität | Gering | Hoch | | Feature Importance | Eingebaut (impurity-basiert) | Eingebaut (gain-basiert) | | Am besten geeignet für | Baseline-Modelle, verrauschte Daten | Wettbewerbe, tabellarische Daten |

Ein zentraler Aspekt beim Gradient Boosting ist das Verständnis des Zusammenspiels zwischen Lernrate und Anzahl der Bäume: Eine kleine Lernrate benötigt mehr Bäume für vergleichbare Ergebnisse, generalisiert aber häufig besser. Moderne Implementierungen wie XGBoost und LightGBM ergänzen die Standardimplementierung von scikit-learn um zusätzliche Optimierungen für große Datensätze. Wer den konzeptuellen Unterschied zwischen Bagging (Random Forest) und Boosting (Gradient Boosting) im Interview erläutern kann, hebt sich deutlich von der Konkurrenz ab.

Unüberwachtes Lernen: Clustering und Dimensionsreduktion

Algorithmen des unüberwachten Lernens finden Strukturen in unbeschrifteten Daten – ohne vorgegebene Ausgaben. Das macht Evaluation schwieriger, da es keine Grundwahrheit gibt, anhand derer man Vorhersagen prüfen kann. K-Means-Clustering und PCA (Principal Component Analysis) sind die beiden Techniken, nach denen Interviewer am häufigsten fragen.

K-Means partitioniert Daten in k Cluster, indem die Varianz innerhalb der Cluster minimiert wird. Der Algorithmus initialisiert k Schwerpunkte zufällig, weist dann jeden Datenpunkt dem nächsten Schwerpunkt zu und berechnet die Schwerpunkte auf Basis der zugewiesenen Punkte neu. Dieser Prozess wiederholt sich bis zur Konvergenz. Zwei kritische Interview-Fragen: Wie wählt man k (Elbow-Methode, Silhouetten-Score) und was passiert bei nicht-sphärischen Clustern? K-Means setzt kugelförmige Cluster gleicher Größe voraus – eine Annahme, die in der Praxis oft verletzt wird.

# kmeans_clustering.py
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.datasets import load_iris

data = load_iris()
X = StandardScaler().fit_transform(data.data)  # Scale features first

# Test multiple values of k to find optimal cluster count
for k in [2, 3, 4, 5]:
    kmeans = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = kmeans.fit_predict(X)
    sil = silhouette_score(X, labels)          # Higher = better-defined clusters
    inertia = kmeans.inertia_                  # Within-cluster sum of squares
    print(f"k={k}: silhouette={sil:.3f}, inertia={inertia:.1f}")

Das Skalieren von Merkmalen vor dem Clustering ist obligatorisch – K-Means verwendet die euklidische Distanz, weshalb unskalierte Merkmale mit großen Wertebereichen die Metrik dominieren und irreführende Cluster erzeugen. Der Silhouetten-Score misst, wie gut ein Punkt zu seinem eigenen Cluster passt im Vergleich zu benachbarten Clustern; Werte nahe 1,0 deuten auf klar getrennte Cluster hin.

PCA reduziert die Dimensionalität, indem Daten auf die Richtungen maximaler Varianz projiziert werden. Diese Richtungen – die Hauptkomponenten – sind orthogonal zueinander und nach erklärter Varianz geordnet. Die Methode dient zwei Zwecken: der Visualisierung (Projektion auf 2D/3D) und der Vorverarbeitung (Rauschentfernung, Beschleunigung nachgelagerter Modelle). In Interviews wird häufig gefragt, wie viele Hauptkomponenten behalten werden sollen – eine gängige Heuristik ist die kumulative erklärte Varianz von 95 %.

Evaluierungsmetriken, die jede Kandidatin und jeder Kandidat beherrschen muss

Die Wahl der richtigen Evaluierungsmetrik ist wichtiger als die Wahl des richtigen Algorithmus. Ein Modell mit 99 % Genauigkeit bei unausgewogenen Daten (1 % Betrugsrate) kann völlig nutzlos sein – es sagt schlicht jedes Mal „kein Betrug" vorher. Dieser klassische Fehler zeigt, dass Accuracy als alleinige Metrik in vielen realen Szenarien unzureichend ist.

Bei der Klassifikation dominieren vier Metriken in Interviews:

• Precision: Von allen positiven Vorhersagen, wie viele sind korrekt? Entscheidend, wenn False Positives kostspielig sind (Spam-Filterung)
• Recall: Von allen tatsächlichen Positiven, wie viele werden gefunden? Entscheidend, wenn False Negatives kostspielig sind (Krankheitsscreening)
• F1-Score: Harmonisches Mittel aus Precision und Recall – die ausgewogene Wahl, wenn keiner der Fehlertypen klar überwiegt
• AUC-ROC: Misst die Ranking-Qualität über alle Klassifikationsschwellenwerte – unverzichtbar für den Modellvergleich

# evaluation_metrics.py
from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix
)
import numpy as np

# Simulated predictions on imbalanced data (5% positive class)
np.random.seed(42)
y_true = np.array([1]*50 + [0]*950)
y_pred = np.array([1]*40 + [0]*10 + [1]*30 + [0]*920)  # Some errors

print(f"Precision: {precision_score(y_true, y_pred):.3f}")  # 40/(40+30) = 0.571
print(f"Recall:    {recall_score(y_true, y_pred):.3f}")     # 40/(40+10) = 0.800
print(f"F1-Score:  {f1_score(y_true, y_pred):.3f}")         # Harmonic mean

cm = confusion_matrix(y_true, y_pred)
print(f"\nConfusion Matrix:\n{cm}")
# [[920, 30],   -> TN=920, FP=30
#  [10,  40]]   -> FN=10,  TP=40

Das Beispiel illustriert eine typische Interviewfalle: Ein Modell, das bei einem unausgewogenen Datensatz ausschließlich auf Accuracy optimiert wird, kann trotzdem hochgradig unbrauchbar sein. Wer die Confusion Matrix zeilenweise lesen und die Auswirkungen von False Negatives und False Positives situationsbezogen erklären kann, demonstriert fundiertes Verständnis. Die ROC-Kurve visualisiert schließlich den Kompromiss zwischen True-Positive-Rate und False-Positive-Rate über alle Schwellenwerte hinweg – je größer die Fläche unter der Kurve (AUC), desto besser die Trennfähigkeit des Modells.

Bias-Varianz-Kompromiss und Regularisierungsstrategien

Der Bias-Varianz-Kompromiss ist das wichtigste konzeptionelle Fundament in der maschinellen Lerntheorie. Jedes Modell weist eine charakteristische Kombination aus Bias und Varianz auf. Hoher Bias bedeutet, dass das Modell zu einfach ist und wichtige Muster in den Daten nicht erfasst – das Ergebnis ist Underfitting. Hohe Varianz bedeutet, dass das Modell zu empfindlich auf die Trainingsdaten reagiert und zufälliges Rauschen als Signal interpretiert – das führt zu Overfitting. Das Ziel ist ein Modell, das weder zu einfach noch zu komplex ist.

Regularisierung kontrolliert die Modellkomplexität, indem große Koeffizienten bestraft werden. Ridge-Regression (L2) fügt der Kostenfunktion die Summe der quadrierten Koeffizienten hinzu und drängt Koeffizienten in Richtung null, behält aber alle Merkmale. Lasso-Regression (L1) fügt stattdessen die Summe der absoluten Koeffizientenwerte hinzu und setzt einige Koeffizienten exakt auf null – was einer automatischen Merkmalsselektion entspricht. Elastic Net kombiniert beide Ansätze über einen Mischungsparameter.

# regularization_comparison.py
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True)

models = {
    "Ridge (L2)":      make_pipeline(StandardScaler(), Ridge(alpha=1.0)),
    "Lasso (L1)":      make_pipeline(StandardScaler(), Lasso(alpha=0.1)),
    "ElasticNet (L1+L2)": make_pipeline(StandardScaler(), ElasticNet(alpha=0.1, l1_ratio=0.5)),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='r2')
    print(f"{name:25s}  R2: {scores.mean():.4f} +/- {scores.std():.4f}")

Der Einsatz von make_pipeline stellt sicher, dass die Standardisierung ausschließlich auf den Trainingsdaten jedes Cross-Validation-Folds berechnet wird – ein weiterer Punkt, den erfahrene Interviewer gezielt abfragen. Data Leakage durch fehlerhafte Vorverarbeitung ist ein klassisches Thema in fortgeschrittenen ML-Gesprächen. Wer erklären kann, warum StandardScaler innerhalb der Pipeline stehen muss und nicht davor, zeigt echtes Verständnis für korrekte Modellentwicklung.

Vorbereitung auf ML-Algorithmenfragen in 2026

Die Vorbereitung auf Machine-Learning-Algorithmenfragen in technischen Interviews geht weit über das Auswendiglernen von Formeln hinaus. Einstellungsteams bewerten drei Dimensionen: theoretisches Verständnis, praktische Implementierung und Urteilsvermögen bei der Algorithmenwahl.

Theoretisches Verständnis bedeutet, die mathematischen Grundlagen hinter Algorithmen erklären zu können – nicht mit perfekter Präzision, aber mit ausreichend Tiefe, um zu zeigen, dass man weiß, warum ein Modell so funktioniert, wie es funktioniert. Wer den Gradientenabstieg, die Kostenfunktion der logistischen Regression oder das Konzept der Informationsgewinnung bei Entscheidungsbäumen erläutern kann, überzeugt in diesem Bereich. Eine nützliche Übung besteht darin, diese Konzepte laut zu erklären, als würde man sie jemandem ohne Fachkenntnis vorstellen.

Praktische Implementierung wird häufig durch Live-Coding-Aufgaben geprüft. Das bedeutet nicht, jeden API-Parameter auswendig zu kennen, sondern ein sauberes, lesbares Skript zu schreiben, das Daten korrekt aufteilt, ein Modell trainiert und Ergebnisse sinnvoll auswertet. Die Verwendung von Pipelines, das korrekte Anwenden von Cross-Validation und das Verständnis der Ausgabe von classification_report sind Grundvoraussetzungen. Wer zusätzlich noch Grenzfälle kommentiert – etwa warum random_state gesetzt wird oder was n_init bei K-Means bewirkt – hinterlässt einen deutlich stärkeren Eindruck.

Urteilsvermögen trennt starke von sehr starken Kandidatinnen und Kandidaten. In der Praxis gibt es keine universell beste Antwort auf die Frage „Welchen Algorithmus würden Sie verwenden?". Die Antwort hängt von Datenmenge, Merkmalstypen, Rechenbudget, Interpretierbarkeitsanforderungen und dem spezifischen Geschäftsproblem ab. Bei einem Modell für Kreditentscheidungen kann Interpretierbarkeit gesetzlich vorgeschrieben sein – in diesem Kontext ist ein schwarzer Kasten wie Gradient Boosting möglicherweise ungeeignet, unabhängig von seiner Vorhersagekraft. Wer diesen Kontext in einer Interviewantwort strukturiert berücksichtigt, demonstriert echte Reife als Data Scientist.

Es empfiehlt sich, ein persönliches Repertoire an Standardvergleichen aufzubauen: linear vs. nicht-linear, parametrisch vs. nicht-parametrisch, Bagging vs. Boosting. Diese konzeptionellen Gegenüberstellungen tauchen in nahezu jedem fortgeschrittenen ML-Interview auf. Ergänzend dazu lohnt es sich, typische Follow-up-Fragen zu antizipieren: Was passiert, wenn die Klassen stark unausgewogen sind? Wie geht man mit fehlenden Werten um? Welche Methode eignet sich zur Hyperparameter-Optimierung?

Fazit

• Lineare Modelle (Regression, logistische Regression) bilden das Fundament jedes ML-Interviews und müssen in- und auswendig beherrscht werden
• Entscheidungsbäume zeigen isoliert Overfitting; Random Forest und Gradient Boosting beheben dieses Problem durch Bagging bzw. Boosting
• K-Means und PCA decken die Grundlagen des unüberwachten Lernens ab – Merkmale müssen jedoch stets zuerst skaliert werden
• Evaluierungsmetriken müssen zum Geschäftsproblem passen – Accuracy allein ist bei unausgewogenen Daten aussagelos
• Regularisierung kontrolliert Overfitting, funktioniert jedoch nur korrekt mit standardisierten Merkmalen innerhalb einer Pipeline
• Interviewerfolg in 2026 setzt voraus, dass Urteilsvermögen bei der Algorithmenwahl demonstriert wird – nicht nur Implementierungsfähigkeit