Top 25 Data-Science-Interviewfragen 2026 – Mit Lösungen und Code

Data-Science-Interviews gehören zu den anspruchsvollsten technischen Auswahlprozessen überhaupt. Kandidatinnen und Kandidaten werden nicht nur auf Programmierkenntnisse geprüft, sondern müssen gleichzeitig statistisches Denken, maschinelles Lernen, Datenbankwissen und die Fähigkeit zur Kommunikation komplexer Ergebnisse unter Beweis stellen. Dieser Leitfaden stellt die 25 wichtigsten Data-Science-Interviewfragen des Jahres 2026 vor – inklusive vollständiger Antworten, lauffähigem Python-Code und praxisnahen Erklärungen, die in realen Vorstellungsgesprächen bei führenden Technologieunternehmen gefragt sind.

Wahrscheinlichkeit und Statistik – Grundlagen (F1–F3)

F1: Was ist ein p-Wert und was sagt er aus?

Der p-Wert ist die Wahrscheinlichkeit, unter der Nullhypothese ein mindestens so extremes Ergebnis zu beobachten wie das tatsächlich gemessene. Ein p-Wert von 0,03 bedeutet: Wäre die Nullhypothese wahr, würde ein so extremes Ergebnis in nur 3 % der Fälle auftreten. Entscheidend ist, was der p-Wert nicht aussagt – er gibt keine Wahrscheinlichkeit an, dass die Nullhypothese wahr oder falsch ist. Häufige Fehler im Interview sind die Verwechslung von statistischer Signifikanz mit praktischer Relevanz sowie das Ignorieren des Problems des multiplen Testens.

# binomial_test.py
from scipy import stats

# Two-sided binomial test: is the coin fair?
result = stats.binomtest(k=8, n=10, p=0.5, alternative='two-sided')
print(f"p-value: {result.pvalue:.4f}")  # 0.1094 (two-sided)
print(f"Reject H0 at alpha=0.05? {result.pvalue < 0.05}")  # False

F2: Was ist der Unterschied zwischen frequentistischer und bayesianischer Statistik?

Die frequentistische Statistik behandelt Parameter als feste, unbekannte Konstanten und schätzt sie aus wiederholten Stichproben. Konfidenzintervalle beschreiben das Verhalten des Schätzverfahrens über viele Wiederholungen, nicht die Wahrscheinlichkeit, dass der wahre Parameter im Intervall liegt. Die bayesianische Statistik hingegen behandelt Parameter als Zufallsvariablen mit einer Priori-Verteilung, die durch beobachtete Daten zur Posteriori-Verteilung aktualisiert wird. Glaubwürdigkeitsintervalle erlauben direkte Wahrscheinlichkeitsaussagen über Parameter. In der Praxis wird die bayesianische Methode bevorzugt, wenn Vorwissen vorhanden ist oder kleine Stichproben vorliegen.

# bayesian_vs_frequentist.py
import numpy as np
from scipy import stats

# Frequentist: confidence interval for a mean
data = np.array([23.1, 25.4, 22.8, 24.9, 23.7, 25.1, 24.3])
ci = stats.t.interval(0.95, df=len(data)-1, loc=np.mean(data), scale=stats.sem(data))
print(f"95% CI (frequentist): [{ci[0]:.2f}, {ci[1]:.2f}]")

# Bayesian: posterior with conjugate prior (Normal-Normal)
prior_mean, prior_var = 24.0, 4.0  # prior belief
data_mean, data_var = np.mean(data), np.var(data, ddof=1) / len(data)
# Posterior parameters (conjugate update)
post_var = 1 / (1/prior_var + 1/data_var)
post_mean = post_var * (prior_mean/prior_var + data_mean/data_var)
post_ci = stats.norm.interval(0.95, loc=post_mean, scale=np.sqrt(post_var))
print(f"95% credible interval (Bayesian): [{post_ci[0]:.2f}, {post_ci[1]:.2f}]")

F3: Erklären Sie den Unterschied zwischen Typ-I- und Typ-II-Fehler. Wie beeinflussen sie das Modelldesign?

Ein Typ-I-Fehler (falsch positiv) bedeutet, die Nullhypothese zu verwerfen, obwohl sie wahr ist – gesteuert durch das Signifikanzniveau Alpha. Ein Typ-II-Fehler (falsch negativ) bedeutet, die Nullhypothese beizubehalten, obwohl sie falsch ist – abhängig von der Teststärke. Im Modellkontext entspricht ein Typ-I-Fehler bei einem Betrugserkenner einem unschuldigen Kunden, der fälschlicherweise gesperrt wird; ein Typ-II-Fehler einem echten Betrugsfall, der nicht erkannt wird. Die richtige Balance hängt vom geschäftlichen Kontext ab: Im medizinischen Screening überwiegen oft die Kosten eines Typ-II-Fehlers, während bei Marketing-Targeting die Kosten eines Typ-I-Fehlers kritischer sein können.

Feature Engineering und Datenvorbereitung (F4–F5)

F4: Welche Strategien gibt es für fehlende Daten?

Fehlende Daten lassen sich in drei Mechanismen einteilen: MCAR (Missing Completely At Random), MAR (Missing At Random) und MNAR (Missing Not At Random). Die Wahl der Imputationsstrategie hängt vom Mechanismus ab. Einfache Mittelwert- oder Medianimputation unterschätzt die Varianz und sollte nur als Baseline dienen. Fortgeschrittene Methoden wie KNN-Imputation oder MICE (Multiple Imputation by Chained Equations) erhalten die Datenstruktur besser. Bei MNAR-Daten ist zusätzlich ein Indikator für das Fehlmuster selbst als Feature wertvoll.

# missing_data_strategies.py
import pandas as pd
from sklearn.impute import KNNImputer, SimpleImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'age': [25, 30, None, 45, None, 38],
    'income': [50000, None, 70000, 90000, 60000, None],
    'score': [85, 90, 78, None, 88, 92]
})

# Strategy 1: KNN imputation (preserves local structure)
knn_imp = KNNImputer(n_neighbors=2)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Strategy 2: Iterative imputation (MICE-like, models each feature)
iter_imp = IterativeImputer(max_iter=10, random_state=42)
df_iter = pd.DataFrame(iter_imp.fit_transform(df), columns=df.columns)

# Strategy 3: Add missingness indicator (preserves signal in the pattern)
df['income_missing'] = df['income'].isna().astype(int)
print(df_knn.round(1))

F5: Was ist Target Encoding und welche Gefahr birgt es?

Target Encoding ersetzt kategorische Werte durch den Mittelwert des Zielwerts innerhalb jeder Kategorie. Die Methode ist besonders nützlich bei hochkardinalem Kategorien, wo One-Hot-Encoding unpraktisch wird. Das Hauptproblem ist Data Leakage: Wenn die Zielvariable in die Kodierung einfließt, ohne die Trainings- und Validierungsdaten zu trennen, sieht der Trainingsdatensatz zu viel. Die Lösung ist K-Fold-Target-Encoding, das die Kodierung für jede Beobachtung ausschließlich aus dem zugehörigen Trainings-Fold berechnet.

# target_encoding.py
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    """Target encoding with K-fold regularization to prevent leakage."""
    encoded = pd.Series(index=df.index, dtype=float)
    global_mean = df[target].mean()
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # Compute means only from training fold
        means = df.iloc[train_idx].groupby(col)[target].mean()
        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(means)

    # Fill categories unseen in training fold with global mean
    encoded.fillna(global_mean, inplace=True)
    return encoded

df = pd.DataFrame({
    'city': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon', 'Paris',
             'Marseille', 'Lyon', 'Paris', 'Marseille'],
    'hired': [1, 0, 1, 0, 1, 1, 0, 0, 1, 1]
})
df['city_encoded'] = target_encode_kfold(df, 'city', 'hired')
print(df[['city', 'city_encoded', 'hired']])

Kernkonzepte des maschinellen Lernens (F6–F9)

F6: Was ist der Bias-Varianz-Kompromiss?

Der Bias-Varianz-Kompromiss beschreibt die fundamentale Spannung zwischen Underfitting und Overfitting. Ein Modell mit hohem Bias macht vereinfachende Annahmen und lernt systematische Muster nicht – der Trainingsfehler ist hoch. Ein Modell mit hoher Varianz reagiert zu empfindlich auf Trainingsdaten und generalisiert schlecht. Der Gesamtfehler setzt sich aus Bias-Quadrat, Varianz und irreduzierblem Rauschen zusammen. Regularisierungsmethoden wie L1 (Lasso) und L2 (Ridge) reduzieren die Varianz auf Kosten eines erhöhten Bias. Ensemblemethoden wie Bagging reduzieren vor allem die Varianz, während Boosting primär den Bias senkt.

F7: Wie funktioniert ein Gradient-Boosting-Algorithmus wie XGBoost?

Gradient Boosting baut sequenziell schwache Lerner auf, wobei jeder neue Baum die Residuen des Vorgängers modelliert. Der Name leitet sich davon ab, dass der Algorithmus den Verlust entlang des negativen Gradienten minimiert – analog zum Gradientenabstieg im Parameterraum, aber im Funktionenraum. XGBoost fügt dem Standardansatz eine zweite Ableitung (Newton-Schritt), Regularisierungsterme in der Zielfunktion, Column Subsampling und eine effiziente Baumkonstruktion mit Approximate Split Finding hinzu. Das Ergebnis ist ein Algorithmus, der bei tabellarischen Daten besonders robust gegen Overfitting und sehr recheneffizient ist.

F8: Was ist der Unterschied zwischen Bagging und Boosting?

Bagging (Bootstrap Aggregating) trainiert mehrere unabhängige Modelle auf Bootstrap-Stichproben und kombiniert ihre Vorhersagen durch Mehrheitsentscheid oder Mittelwertbildung. Jedes Modell wird parallel trainiert, und der Haupteffekt ist eine Reduktion der Varianz – klassisches Beispiel ist Random Forest. Boosting hingegen trainiert Modelle sequenziell: Jedes neue Modell konzentriert sich auf die Beispiele, die der Vorgänger falsch klassifiziert hat. Der Haupteffekt ist eine Reduktion des Bias bei gleichzeitig moderater Varianzreduktion. Boosting-Modelle sind anfälliger für Ausreißer und Rauschen, erzielen aber bei sauberen Daten oft bessere Ergebnisse.

F9: Was ist Regularisierung und wann ist L1 gegenüber L2 vorzuziehen?

Regularisierung fügt der Verlustfunktion einen Strafterm für große Gewichte hinzu, um Overfitting zu reduzieren. L2-Regularisierung (Ridge) addiert die Summe der quadrierten Gewichte und führt zu kleinen, aber von null verschiedenen Gewichten – besonders effektiv, wenn viele Features schwache, aber nicht vernachlässigbare Beiträge leisten. L1-Regularisierung (Lasso) addiert die Summe der absoluten Gewichte und erzeugt echte Nullgewichte – wirkt damit als automatische Feature-Selektion. Elastic Net kombiniert beide Ansätze. L1 wird bevorzugt, wenn angenommen wird, dass nur wenige Features wirklich relevant sind. L2 ist robuster, wenn viele korrelierte Features vorliegen.

Modellbewertung und Validierung (F10–F11)

F10: Wie werden Modelle bei stark unausgewogenen Klassen bewertet?

Bei unausgewogenen Klassifikationsproblemen ist die Genauigkeit (Accuracy) eine irreführende Metrik: Ein Modell, das immer die Mehrheitsklasse vorhersagt, erreicht 95 % Genauigkeit ohne jede Nützlichkeit. Sinnvollere Metriken sind Precision und Recall für die Minderheitsklasse sowie der F1-Score als harmonisches Mittel. Die ROC-AUC misst die Rangordnungsqualität über alle Schwellenwerte, ist jedoch bei starker Unausgewogenheit optimistisch. Die Precision-Recall-AUC (Average Precision) ist bei sehr starkem Ungleichgewicht die aussagekräftigere Metrik.

# imbalanced_metrics.py
from sklearn.metrics import (
    classification_report, precision_recall_curve,
    average_precision_score, roc_auc_score
)
import numpy as np

# Simulated predictions on imbalanced data
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 95/5 imbalance
y_scores = np.random.beta(2, 5, 1000)  # predicted probabilities
y_scores[y_true == 1] += 0.3  # positive class scores slightly higher
y_scores = np.clip(y_scores, 0, 1)
y_pred = (y_scores > 0.5).astype(int)

print(classification_report(y_true, y_pred, digits=3))
print(f"ROC AUC: {roc_auc_score(y_true, y_scores):.3f}")
print(f"Average Precision (AUPRC): {average_precision_score(y_true, y_scores):.3f}")

F11: Was ist Data Leakage und wie wird es verhindert?

Data Leakage bezeichnet das unbeabsichtigte Einbeziehen von Information aus dem Testdatensatz in das Training, was zu übertrieben optimistischen Evaluierungsergebnissen führt. Die häufigsten Quellen sind: Standardisierung oder Imputation auf dem gesamten Datensatz vor der Aufteilung in Trainings- und Testdaten, zeitliche Datenlecks bei Zeitreihenproblemen und zielkorrelierte Merkmale, die nach dem Ereignis entstehen. Die zuverlässigste Gegenmaßnahme ist die Verwendung von Scikit-learn Pipelines, die sicherstellen, dass alle Transformationsschritte ausschließlich auf den Trainingsfolds gefittet werden.

# leakage_prevention.py
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# WRONG: fit scaler on all data, then cross-validate
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # leakage: test fold info in scaling

# CORRECT: pipeline ensures preprocessing fits only on training folds
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC (no leakage): {scores.mean():.3f} +/- {scores.std():.3f}")

Deep Learning und neuronale Netze (F12–F14)

F12: Wie funktioniert der Self-Attention-Mechanismus in Transformer-Modellen?

Self-Attention ermöglicht jedem Token einer Sequenz, direkte Abhängigkeiten zu jedem anderen Token zu berechnen – unabhängig von der Distanz. Für jedes Token werden drei Vektoren berechnet: Query (Q), Key (K) und Value (V) durch lineare Projektionen. Die Attention-Gewichte entstehen durch skaliertes Skalarprodukt zwischen Q und allen K, normiert durch Softmax. Die Skalierung durch die Quadratwurzel der Schlüsseldimension verhindert, dass bei großen Dimensionen die Skalarprodukte zu groß werden und Softmax in Sättigungsbereiche gerät. Multihead Attention führt diesen Mechanismus parallel in mehreren Unterräumen aus, was das Erlernen verschiedenartiger Abhängigkeiten erlaubt.

# self_attention.py
import torch
import torch.nn.functional as F

def self_attention(x, d_k):
    """Scaled dot-product self-attention from scratch."""
    # x shape: (batch_size, seq_len, d_model)
    batch_size, seq_len, d_model = x.shape

    # Linear projections for Q, K, V
    W_q = torch.randn(d_model, d_k) * 0.1
    W_k = torch.randn(d_model, d_k) * 0.1
    W_v = torch.randn(d_model, d_k) * 0.1

    Q = x @ W_q  # (batch, seq_len, d_k)
    K = x @ W_k
    V = x @ W_v

    # Scaled dot-product attention
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)  # (batch, seq_len, seq_len)
    weights = F.softmax(scores, dim=-1)  # attention weights
    output = weights @ V  # (batch, seq_len, d_k)

    return output, weights

# Example: 1 batch, 4 tokens, 8-dim embeddings
x = torch.randn(1, 4, 8)
out, attn = self_attention(x, d_k=8)
print(f"Output shape: {out.shape}")    # (1, 4, 8)
print(f"Attention weights:\n{attn[0].detach().numpy().round(3)}")

F13: Was sind Vanishing Gradients und wie werden sie adressiert?

Vanishing Gradients entstehen, wenn Gradienten bei der Rückpropagation durch viele Schichten multipliziert werden und dabei exponentiell klein werden – besonders bei Aktivierungsfunktionen wie Sigmoid und Tanh, deren Ableitungen maximal 0,25 bzw. 1,0 betragen. Tiefe Netze lernen frühe Schichten dadurch kaum noch. Moderne Lösungsansätze umfassen: ReLU und seine Varianten (Leaky ReLU, GELU) mit nahezu konstanter Ableitung im positiven Bereich, Residualverbindungen (Skip Connections) in ResNet, die den Gradienten einen direkten Pfad durch das Netz bieten, und Batch Normalization, das Aktivierungen normalisiert und die Gradienten stabilisiert.

F14: Was ist der Unterschied zwischen Batch Normalization und Layer Normalization?

Batch Normalization normalisiert über die Batch-Dimension: Für jeden Feature-Kanal wird der Mittelwert und die Standardabweichung über alle Beispiele im Minibatch berechnet. Das funktioniert gut für CNNs und große Batches, versagt aber bei kleinen Batches und beim autoregressiven Decoding in Transformern. Layer Normalization normalisiert über die Feature-Dimension: Für jede Beobachtung einzeln, unabhängig von der Batchgröße. Deshalb ist Layer Normalization die Standardwahl in Transformer-Architekturen, wo Batches klein sein können und sequenzielle Verarbeitung erforderlich ist.

SQL und Datenmanipulation (F15–F16)

F15: Schreiben Sie eine SQL-Abfrage für das zweithöchste Gehalt je Abteilung.

Diese Frage testet Kenntnisse über korrelierende Subqueries und Window Functions. Der eleganteste Ansatz verwendet eine korrelierende Subquery, die für jeden Mitarbeiter zählt, wie viele verschiedene Gehälter in derselben Abteilung höher sind. Genau ein höheres Gehalt entspricht dem zweithöchsten Rang.

-- second_highest_salary.sql
-- Approach: correlated subquery counting distinct higher salaries
SELECT d.department_name, e.employee_name, e.salary
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
      AND e2.salary > e.salary
) = 1
ORDER BY d.department_name;

F16: Erklären Sie den Unterschied zwischen INNER JOIN, LEFT JOIN und CROSS JOIN.

Ein INNER JOIN gibt nur Zeilen zurück, für die in beiden Tabellen ein übereinstimmender Schlüssel existiert – nicht übereinstimmende Zeilen werden ausgeschlossen. Ein LEFT JOIN gibt alle Zeilen der linken Tabelle zurück; Zeilen ohne Treffer in der rechten Tabelle werden mit NULL aufgefüllt. Das ist besonders wichtig in der Datenanalyse, wo fehlende Zuordnungen selbst aussagekräftig sind. Ein CROSS JOIN erzeugt das kartesische Produkt aller Zeilenkombinationen und ist selten sinnvoll, aber bei der Erstellung von Merkmalskombinationen oder Testdatensätzen nützlich.

Angewandte Data Science und System Design (F17–F20)

F17: Wie wird eine A/B-Testinfrastruktur für ein Empfehlungssystem entworfen?

Ein robustes A/B-Test-Design umfasst vier Kernkomponenten: Randomisierung auf der richtigen Ebene (Nutzer-ID, Session oder Gerät), abhängig davon, auf welcher Ebene die Behandlung stattfindet; Guardrail-Metriken, um sicherzustellen, dass das Experiment keine anderen Kernmetriken verletzt; Verkehrsaufteilung mit konsistentem Hashing, damit dieselben Nutzer stets dieselbe Variante sehen; und statistische Analyse nach Ablauf einer vorher festgelegten Laufzeit, um P-Hacking durch frühzeitiges Abbrechen zu vermeiden. Für mehrvariante Tests ist eine Bonferroni-Korrektur oder FDR-Kontrolle notwendig.

F18: Wie wird eine Feature-Store-Architektur aufgebaut?

Ein Feature Store trennt Feature-Berechnung von Feature-Konsumierung und stellt Features sowohl für Training (Offline) als auch für Inferenz (Online) bereit. Die Offline-Komponente umfasst eine Data-Warehouse-Integration mit historischen Point-in-Time-korrekten Features. Die Online-Komponente nutzt einen Low-Latency-Cache für Sub-Millisekunden-Lookups während der Echtzeit-Inferenz. Kritisch ist die Feature-Konsistenz zwischen Training und Serving (Training-Serving Skew), die durch gemeinsame Berechnungslogik in beiden Pipelines minimiert wird. Populäre Open-Source-Lösungen sind Feast und Hopsworks.

F19: Welche Strategien gibt es für das Deployment von ML-Modellen in der Produktion?

Das ML-Deployment umfasst mehrere Muster: Blue-Green-Deployment für sofortige Rollbacks ohne Ausfallzeit, Canary Releases für schrittweise Einführungen mit automatischer Rollback-Auslösung bei Metrik-Verschlechterung, und Shadow Mode für das parallele Testen neuer Modelle ohne Produktionswirkung. Monitoring umfasst drei Ebenen: technische Metriken (Latenz, Fehlerrate), Modellmetriken (Vorhersageverteilung, Confidence-Histogramme) und Geschäftsmetriken (Konversionsrate, Revenue pro Empfehlung). Data Drift und Concept Drift erfordern automatisierte Detektionssysteme.

F20: Was ist Simpson's Paradox und warum ist es für Data Scientists relevant?

Simpson's Paradox beschreibt die Situation, in der ein Trend in den aggregierten Daten verschwindet oder sich umkehrt, wenn die Daten nach einer Confounder-Variable aufgeteilt werden. Ein klassisches Beispiel: Eine Behandlung erscheint in der Gesamtpopulation schlechter, ist aber in jeder Subgruppe besser – weil die Gruppen unterschiedlich groß sind und unterschiedliche Ausgangswerte haben. Für Data Scientists ist dieses Paradox allgegenwärtig bei der Analyse von Konversionsraten, medizinischen Studien und Plattform-Metriken. Die Lösung liegt in der Stratifizierung nach bekannten Confoundern und im Einsatz kausaler Methoden.

Python und Pandas (F21–F22)

F21: Was ist der Unterschied zwischen map, apply und transform in Pandas?

Diese drei Methoden lösen ähnliche, aber unterschiedliche Probleme. map ist ausschließlich für Series-Objekte und wendet eine elementweise Transformation an – ideal für einfache Werteersetzungen und Dictionary-Lookups. apply ist flexibler und akzeptiert beliebige Funktionen auf Series oder DataFrames, verarbeitet jedoch Zeile für Zeile und ist daher bei großen DataFrames langsamer als vektorisierte Operationen. transform ist für GroupBy-Operationen gedacht: Es gibt ein Ergebnis mit derselben Form wie die Eingabe zurück und ermöglicht so, gruppenbasierte Statistiken direkt im DataFrame zu ergänzen – ohne den Index zu verändern.

# pandas_operations.py
import pandas as pd

df = pd.DataFrame({
    'team': ['A', 'A', 'B', 'B', 'A'],
    'score': [10, 20, 30, 40, 50]
})

# map: element-wise on Series
df['team_upper'] = df['team'].map({'A': 'Alpha', 'B': 'Beta'})

# apply: arbitrary function per row
df['score_label'] = df['score'].apply(lambda x: 'high' if x > 25 else 'low')

# transform: group-level, same shape output (broadcasts back)
df['team_mean'] = df.groupby('team')['score'].transform('mean')
df['score_normalized'] = df.groupby('team')['score'].transform(
    lambda x: (x - x.mean()) / x.std()
)
print(df)

F22: Wie werden Feature Importances mit SHAP erklärt?

Tree-basierte Feature Importances haben einen bekannten Nachteil: Sie bevorzugen systematisch Features mit hoher Kardinalität und sind nicht modellunabhängig. SHAP (SHapley Additive exPlanations) basiert auf der spieltheoretischen Shapley-Wert-Theorie und verteilt den Vorhersagebeitrag fair auf alle Features – konsistent, lokal korrekt und summenkonform. TreeSHAP berechnet exakte Shapley-Werte für baumbasierte Modelle in polynomialer Zeit. Globale Interpretationen entstehen durch Aggregation der absoluten SHAP-Werte über alle Trainingsbeispiele.

# feature_importance_shap.py
import shap
import xgboost as xgb
from sklearn.datasets import make_classification

# Generate synthetic dataset
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)

# Train XGBoost model
model = xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')
model.fit(X, y)

# SHAP explanation
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)

# Global importance: mean absolute SHAP value per feature
import numpy as np
importance = np.abs(shap_values).mean(axis=0)
for i in np.argsort(importance)[::-1]:
    print(f"Feature {i}: {importance[i]:.4f}")

Dimensionsreduktion und unüberwachtes Lernen (F23–F24)

F23: Wann ist PCA gegenüber t-SNE oder UMAP vorzuziehen?

PCA, t-SNE und UMAP dienen alle der Dimensionsreduktion, verfolgen jedoch unterschiedliche Ziele. PCA ist eine lineare Methode, die die maximale globale Varianz erhält und in der Vorverarbeitung vor supervised Learning eingesetzt wird. t-SNE ist eine nichtlineare Methode, die lokale Nachbarschaften erhält und vor allem für die Visualisierung von Clustern in 2D geeignet ist – bei großen Datensätzen jedoch sehr langsam. UMAP erhält sowohl lokale als auch teilweise globale Struktur, ist deutlich schneller und zunehmend der bevorzugte Ansatz für Visualisierung und Vorverarbeitung gleichermaßen.

| Methode | Linear | Globale Struktur | Geschwindigkeit (100K Punkte) | Anwendungsfall | |---------|--------|------------------|-------------------------------|----------------| | PCA | Ja | Ja | Sekunden | Vorverarbeitung, Feature-Reduktion | | t-SNE | Nein | Nein | Minuten | Clustervisualisierung (kleine Daten) | | UMAP | Nein | Teilweise | Sekunden | Visualisierung + Vorverarbeitung |

F24: Was ist der Unterschied zwischen K-Means und DBSCAN?

K-Means partitioniert Daten in k kugelförmige Cluster durch iterative Centroid-Optimierung. Die Anzahl der Cluster muss vorab festgelegt werden, und der Algorithmus ist empfindlich gegenüber Ausreißern und nicht-kugelförmigen Clustern. DBSCAN (Density-Based Spatial Clustering of Applications with Noise) gruppiert Punkte basierend auf lokaler Dichte und benötigt keine Vorspezifikation der Clusteranzahl. Ausreißer werden explizit als Rauschen klassifiziert, und der Algorithmus erkennt beliebig geformte Cluster. Der Nachteil: DBSCAN skaliert schlecht bei variierenden Dichten und erfordert Feinabstimmung der Parameter Epsilon und MinPts.

Kommunikation und geschäftlicher Impact (F25)

F25: Wie wird einem nicht-technischen Stakeholder erklärt, warum ein ML-Modell eine bestimmte Entscheidung getroffen hat?

Die Erklärung von Modellentscheidungen an nicht-technische Stakeholder erfordert eine klare Trennung zwischen der globalen Modelllogik und der lokalen Instanz-Erklärung. LIME und SHAP bieten lokale Erklärungen auf Instanzebene: Für einen bestimmten Kunden war der wichtigste Faktor für die Kreditablehnung das Verhältnis von Schulden zu Einkommen, gefolgt von der kurzen Kredithistorie. Für regelbasierte Stakeholder sind Entscheidungsbäume mit geringer Tiefe oder Monotone-Constraint-Modelle interpretierbar und prüfbar. In regulierten Industrien sind die Anforderungen an Erklärbarkeit durch EU-Regulierungen wie den AI Act und DSGVO-Artikel 22 zunehmend verbindlich.

Fazit

Die Vorbereitung auf ein Data-Science-Interview 2026 erfordert Kenntnisse über mehrere Disziplinen hinweg:

• Statistik und Wahrscheinlichkeitsrechnung – p-Werte, Hypothesentests, Bayes-Methoden und experimentelles Design sind grundlegende Gesprächsthemen in jedem seriösen Interview
• Feature Engineering – Strategien für fehlende Daten, Target Encoding und Leakage-Prävention zeigen praktische Erfahrung
• ML-Theorie – der Bias-Varianz-Kompromiss, Ensemble-Methoden und Regularisierung bilden das konzeptionelle Fundament
• Modellbewertung – korrekte Metriken bei unausgewogenen Klassen und Leakage-Prävention sind Kriterien, an denen erfahrene Kandidaten erkannt werden
• Deep Learning – Transformer-Architekturen, Aufmerksamkeitsmechanismen und Normalisierungsmethoden sind in 2026 unverzichtbares Standardwissen
• SQL und Datenmanipulation – Joins, Window Functions und korrelierende Subqueries sind in jedem Interview zu erwarten
• System Design – A/B-Testing, Feature Stores und Deployment-Strategien differenzieren Senior-Kandidaten
• Kommunikation – die Fähigkeit, Modellentscheidungen verständlich zu erklären, ist in regulierten Branchen ein Einstellungskriterium