# Feature Engineering für Machine Learning: Techniken und Interview-Fragen 2026

> Feature Engineering für ML-Interviews meistern: Skalierung, Encoding, Feature Selection und zeitbasierte Features mit Python-Codebeispielen.

- Published: 2026-05-08
- Updated: 2026-05-08
- Author: SharpSkill
- Tags: feature-engineering, machine-learning, data-science, interview, python
- Reading time: 12 min

---

Feature Engineering gilt als eine der entscheidenden Disziplinen im Bereich Machine Learning und Data Science. Wer ein **feature engineering interview** erfolgreich bestehen möchte, muss nicht nur theoretisches Wissen mitbringen, sondern auch praktische Techniken sicher beherrschen. Dieser Artikel behandelt die wichtigsten Methoden, die in **data science interview questions** regelmäßig abgefragt werden, und liefert produktionsreife Python-Codebeispiele für jede Technik.

> **Profi-Tipp**
>
> Feature Engineering macht in der Praxis oft den größeren Unterschied als die Wahl des Algorithmus. Interviewer achten besonders darauf, ob Kandidaten systematisch an die Aufbereitung von Features herangehen und dabei Domänenwissen einbeziehen.

## Was Feature Engineering in der Praxis bedeutet

Unter **machine learning feature engineering** versteht man den gesamten Prozess der Transformation, Erstellung und Auswahl von Eingabevariablen für ein Modell. Rohdaten enthalten selten die optimale Repräsentation für einen Algorithmus. Feature Engineering schließt diese Lücke zwischen Rohdaten und Modellperformance.

Der Prozess umfasst mehrere Stufen: Bereinigung fehlender Werte, Skalierung numerischer Features, Encoding kategorialer Variablen, Erstellung neuer Features aus bestehenden Daten und die gezielte Auswahl der relevantesten Merkmale. Jede dieser Stufen erfordert fundierte Entscheidungen, die sich direkt auf die Modellqualität auswirken.

In Interviews wird häufig gefragt, warum Feature Engineering vor dem Modelltraining stattfinden muss und welche Risiken entstehen, wenn dieser Schritt übersprungen wird. Die Antwort liegt in der Datenqualität: Ein komplexes Modell kann schlechte Features nicht kompensieren.

## Feature-Skalierung und Normalisierung

Unterschiedliche Skalen bei numerischen Features führen dazu, dass Algorithmen wie Gradient Descent, SVM oder k-NN verzerrte Ergebnisse liefern. Skalierung bringt alle Features auf einen vergleichbaren Wertebereich.

```python
# feature_scaling.py
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

df = pd.DataFrame({
    "gehalt": [35000, 72000, 120000, 45000, 88000],
    "erfahrung_jahre": [2, 5, 12, 3, 7],
    "projekte": [4, 15, 30, 6, 20]
})

# StandardScaler: Mittelwert=0, Standardabweichung=1
standard_scaler = StandardScaler()
df_standard = pd.DataFrame(
    standard_scaler.fit_transform(df),
    columns=df.columns
)

# MinMaxScaler: Werte zwischen 0 und 1
minmax_scaler = MinMaxScaler()
df_minmax = pd.DataFrame(
    minmax_scaler.fit_transform(df),
    columns=df.columns
)

# RobustScaler: Robust gegenueber Ausreissern (nutzt Median und IQR)
robust_scaler = RobustScaler()
df_robust = pd.DataFrame(
    robust_scaler.fit_transform(df),
    columns=df.columns
)

print("StandardScaler:\\n", df_standard.round(3))
print("\\nRobustScaler:\\n", df_robust.round(3))
```

Die Wahl des Scalers hängt von der Datenverteilung ab. StandardScaler eignet sich für annähernd normalverteilte Daten. Bei Ausreißern liefert RobustScaler stabilere Ergebnisse, da er auf Median und Interquartilsabstand basiert. MinMaxScaler ist sinnvoll, wenn ein fester Wertebereich benötigt wird, etwa bei neuronalen Netzen mit Sigmoid-Aktivierung.

## Encoding kategorialer Variablen

Machine-Learning-Modelle arbeiten mit numerischen Werten. Kategoriale Variablen müssen daher in eine numerische Repräsentation überführt werden, ohne dabei künstliche Ordnungsbeziehungen zu erzeugen.

```python
# categorical_encoding.py
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
from category_encoders import TargetEncoder

df = pd.DataFrame({
    "stadt": ["Berlin", "Muenchen", "Hamburg", "Berlin", "Koeln", "Muenchen"],
    "erfahrungslevel": ["Junior", "Senior", "Mid", "Mid", "Senior", "Junior"],
    "gehalt": [42000, 85000, 62000, 48000, 78000, 40000]
})

# One-Hot Encoding: Fuer nominale Variablen ohne Ordnung
df_onehot = pd.get_dummies(df, columns=["stadt"], prefix="stadt", dtype=int)
print("One-Hot Encoding:\\n", df_onehot)

# Ordinal Encoding: Fuer Variablen mit natuerlicher Reihenfolge
level_order = [["Junior", "Mid", "Senior"]]
ordinal_enc = OrdinalEncoder(categories=level_order)
df["level_encoded"] = ordinal_enc.fit_transform(df[["erfahrungslevel"]])

# Target Encoding: Ersetzt Kategorie durch Mittelwert der Zielvariable
target_enc = TargetEncoder(cols=["stadt"], smoothing=2.0)
df["stadt_target"] = target_enc.fit_transform(df["stadt"], df["gehalt"])

print("\\nTarget Encoding:\\n", df[["stadt", "stadt_target", "gehalt"]])
```

One-Hot Encoding erzeugt bei hoher Kardinalität sehr viele Spalten. Target Encoding löst dieses Problem, birgt aber das Risiko von Data Leakage. In Interviews wird häufig nach Strategien gefragt, um Target Leakage zu vermeiden — die Antwort lautet: K-Fold Target Encoding, bei dem die Zielwerte nur aus anderen Folds berechnet werden.

## Feature-Selection-Techniken im Detail

Nicht jedes Feature verbessert ein Modell. Irrelevante oder redundante Features erhöhen die Dimensionalität, verlangsamen das Training und können zu Overfitting führen. **Feature selection techniques** lassen sich in drei Kategorien einteilen: Filter-, Wrapper- und Embedded-Methoden.

```python
# feature_selection.py
import pandas as pd
import numpy as np
from sklearn.datasets import make_classification
from sklearn.feature_selection import (
    mutual_info_classif,
    SelectKBest,
    f_classif,
    SequentialFeatureSelector
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LassoCV

X, y = make_classification(
    n_samples=1000, n_features=20, n_informative=8,
    n_redundant=5, n_classes=2, random_state=42
)
feature_names = [f"feature_{i}" for i in range(20)]
df = pd.DataFrame(X, columns=feature_names)

# Filter-Methode: Mutual Information
mi_scores = mutual_info_classif(X, y, random_state=42)
mi_ranking = pd.Series(mi_scores, index=feature_names).sort_values(ascending=False)
print("Top 8 Features (Mutual Information):")
print(mi_ranking.head(8))

# Filter-Methode: ANOVA F-Test
selector = SelectKBest(score_func=f_classif, k=8)
X_selected = selector.fit_transform(X, y)
selected_mask = selector.get_support()
print(f"\\nANOVA-selektierte Features: {np.array(feature_names)[selected_mask].tolist()}")

# Embedded-Methode: L1-Regularisierung (Lasso)
lasso = LassoCV(cv=5, random_state=42)
lasso.fit(X, y)
lasso_importance = pd.Series(np.abs(lasso.coef_), index=feature_names)
print(f"\\nLasso (nicht-null Features): {(lasso_importance > 0).sum()}")

# Embedded-Methode: Random Forest Feature Importance
rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X, y)
rf_importance = pd.Series(rf.feature_importances_, index=feature_names)
print("\\nTop 8 Features (Random Forest):")
print(rf_importance.sort_values(ascending=False).head(8))
```

Filter-Methoden wie Mutual Information sind schnell und modellunabhängig, berücksichtigen aber keine Feature-Interaktionen. Embedded-Methoden wie Lasso oder Random Forest Importance bewerten Features im Kontext des Modells. Wrapper-Methoden wie Sequential Feature Selection liefern oft die besten Ergebnisse, sind aber rechenintensiv. In der Praxis empfiehlt sich eine Kombination: erst Filter zur Vorauswahl, dann Embedded-Methoden zur Feinauswahl.

## Interaktions-Features erstellen

Interaktions-Features erfassen Beziehungen zwischen Variablen, die ein Modell allein aus den Einzelfeatures nicht ableiten kann. Besonders bei linearen Modellen steigern sie die Ausdruckskraft erheblich.

```python
# interaction_features.py
import pandas as pd
import numpy as np
from sklearn.preprocessing import PolynomialFeatures

df = pd.DataFrame({
    "wohnflaeche": [60, 85, 120, 45, 200],
    "zimmer": [2, 3, 4, 1, 6],
    "baujahr": [1990, 2005, 2018, 1975, 2022],
    "stockwerk": [3, 1, 5, 0, 8]
})

# Manuelle Interaktions-Features mit Domaenenwissen
df["flaeche_pro_zimmer"] = df["wohnflaeche"] / df["zimmer"]
df["gebaeude_alter"] = 2026 - df["baujahr"]
df["flaeche_x_stockwerk"] = df["wohnflaeche"] * df["stockwerk"]
df["log_wohnflaeche"] = np.log1p(df["wohnflaeche"])

# Automatische polynomiale Interaktionen (Grad 2)
poly = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
feature_cols = ["wohnflaeche", "zimmer", "stockwerk"]
X_poly = poly.fit_transform(df[feature_cols])
poly_names = poly.get_feature_names_out(feature_cols)

df_poly = pd.DataFrame(X_poly, columns=poly_names)
print("Polynomiale Features:\\n", df_poly.head())
print(f"\\nAnzahl Features: {len(poly_names)} (von {len(feature_cols)} Ursprungsfeatures)")

# Binning als nicht-lineare Transformation
df["flaeche_kategorie"] = pd.qcut(
    df["wohnflaeche"], q=3, labels=["klein", "mittel", "gross"]
)
print("\\nBinning:\\n", df[["wohnflaeche", "flaeche_kategorie"]])
```

Domänenspezifische Features wie "Fläche pro Zimmer" übertreffen automatisch generierte Interaktionen in der Regel deutlich. Interviewer bewerten positiv, wenn Kandidaten erklären können, warum ein bestimmtes Interaktions-Feature inhaltlich sinnvoll ist, statt blind alle Kombinationen zu erzeugen.

## Umgang mit fehlenden Werten

Fehlende Werte sind in realen Datensätzen unvermeidlich. Die Behandlungsstrategie beeinflusst die Modellqualität erheblich und gehört zu den häufigsten **data science interview questions**.

```python
# missing_values.py
import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

np.random.seed(42)
df = pd.DataFrame({
    "alter": [25, np.nan, 35, 42, np.nan, 55, 30, np.nan, 48, 33],
    "einkommen": [30000, 45000, np.nan, 72000, 38000, np.nan, 51000, 42000, np.nan, 47000],
    "bewertung": [3.5, 4.0, np.nan, 4.5, 3.0, 4.2, np.nan, 3.8, 4.1, np.nan]
})

# Analyse fehlender Werte
print("Fehlende Werte pro Spalte:")
print(df.isnull().sum())
print(f"\\nAnteil fehlend: {df.isnull().mean().round(3).to_dict()}")

# Indikator-Features: Information ueber Fehlen bewahren
for col in df.columns:
    df[f"{col}_fehlend"] = df[col].isnull().astype(int)

# Median-Imputation (robust gegenueber Ausreissern)
median_imputer = SimpleImputer(strategy="median")
df_median = pd.DataFrame(
    median_imputer.fit_transform(df[["alter", "einkommen", "bewertung"]]),
    columns=["alter", "einkommen", "bewertung"]
)

# KNN-Imputation: Nutzt aehnliche Datenpunkte
knn_imputer = KNNImputer(n_neighbors=3)
df_knn = pd.DataFrame(
    knn_imputer.fit_transform(df[["alter", "einkommen", "bewertung"]]),
    columns=["alter", "einkommen", "bewertung"]
)

# Iterative Imputation (MICE-Algorithmus)
mice_imputer = IterativeImputer(max_iter=10, random_state=42)
df_mice = pd.DataFrame(
    mice_imputer.fit_transform(df[["alter", "einkommen", "bewertung"]]),
    columns=["alter", "einkommen", "bewertung"]
)

print("\\nVergleich der Imputationsmethoden (Spalte 'alter'):")
print(f"  Median: {df_median['alter'].values}")
print(f"  KNN:    {df_knn['alter'].round(1).values}")
print(f"  MICE:   {df_mice['alter'].round(1).values}")
```

Ein oft übersehener Aspekt: Das Fehlen selbst kann Information tragen. Indikator-Features, die kennzeichnen, ob ein Wert ursprünglich fehlte, verbessern in vielen Fällen die Vorhersagequalität. KNN- und MICE-Imputation berücksichtigen Zusammenhänge zwischen Variablen und liefern realistischere Schätzungen als einfache Mittelwert-Imputation.

## Zeitbasiertes Feature Engineering

Zeitreihen und zeitgestempelte Daten erfordern spezielle Techniken. Lag-Features, Rolling-Statistiken und zyklische Encodings gehören zum Standardrepertoire im **machine learning feature engineering**.

```python
# time_features.py
import pandas as pd
import numpy as np

dates = pd.date_range("2025-01-01", periods=365, freq="D")
np.random.seed(42)
df = pd.DataFrame({
    "datum": dates,
    "umsatz": np.random.normal(1000, 200, 365).cumsum() + 50000
})

# Kalender-Features extrahieren
df["jahr"] = df["datum"].dt.year
df["monat"] = df["datum"].dt.month
df["wochentag"] = df["datum"].dt.dayofweek
df["quartal"] = df["datum"].dt.quarter
df["ist_wochenende"] = (df["wochentag"] >= 5).astype(int)
df["tag_im_jahr"] = df["datum"].dt.dayofyear

# Zyklisches Encoding: Vermeidet kuenstliche Spruenge (Dez->Jan)
df["monat_sin"] = np.sin(2 * np.pi * df["monat"] / 12)
df["monat_cos"] = np.cos(2 * np.pi * df["monat"] / 12)
df["wochentag_sin"] = np.sin(2 * np.pi * df["wochentag"] / 7)
df["wochentag_cos"] = np.cos(2 * np.pi * df["wochentag"] / 7)

# Lag-Features: Vergangene Werte als Praediktor
for lag in [1, 7, 14, 30]:
    df[f"umsatz_lag_{lag}"] = df["umsatz"].shift(lag)

# Rolling-Statistiken: Gleitende Fenster
for window in [7, 14, 30]:
    df[f"umsatz_rolling_mean_{window}"] = (
        df["umsatz"].rolling(window=window, min_periods=1).mean()
    )
    df[f"umsatz_rolling_std_{window}"] = (
        df["umsatz"].rolling(window=window, min_periods=1).std()
    )

# Expanding Features: Kumulative Statistiken
df["umsatz_expanding_mean"] = df["umsatz"].expanding().mean()
df["umsatz_pct_change_7d"] = df["umsatz"].pct_change(periods=7)

print("Zeitbasierte Features (letzte 5 Zeilen):")
print(df[["datum", "umsatz", "umsatz_lag_7", "umsatz_rolling_mean_7",
          "monat_sin", "monat_cos"]].tail())
print(f"\\nGesamte Feature-Anzahl: {len(df.columns)}")
```

Zyklisches Encoding mit Sinus und Kosinus ist ein häufiges Interview-Thema. Es löst das Problem, dass ordinale Encodings von Monaten oder Wochentagen künstliche Distanzen erzeugen — der Abstand zwischen Dezember (12) und Januar (1) wäre numerisch größer als zwischen Januar und Februar, was inhaltlich falsch ist. Die Sinus-Kosinus-Transformation bildet die zyklische Natur korrekt ab.

## Häufige Interview-Fragen und Antwortstrategien

Neben den technischen Implementierungen tauchen in Vorstellungsgesprächen regelmäßig konzeptionelle Fragen auf. Hier sind die wichtigsten Themenbereiche, die bei **feature selection techniques** und Feature Engineering geprüft werden:

**Data Leakage vermeiden**: Jede Transformation, die auf dem gesamten Datensatz berechnet wird, bevor Train-Test-Split stattfindet, erzeugt Leakage. Skalierung, Imputation und Encoding müssen innerhalb einer Pipeline auf den Trainingsdaten gefittet und auf die Testdaten nur transformiert werden.

**Feature Importance vs. Feature Selection**: Feature Importance gibt an, wie stark ein Feature zur Vorhersage beiträgt. Feature Selection nutzt diese Information, um irrelevante Features zu entfernen. Beides ist nicht identisch — ein Feature mit hoher Importance kann redundant sein, wenn ein korreliertes Feature bereits vorhanden ist.

**Curse of Dimensionality**: Mit steigender Feature-Anzahl wächst der benötigte Datenumfang exponentiell. Feature Selection und Dimensionalitätsreduktion sind daher keine Optimierung, sondern eine Notwendigkeit bei hochdimensionalen Daten.

**Multikollinearität**: Stark korrelierte Features destabilisieren lineare Modelle. Der Variance Inflation Factor (VIF) quantifiziert dieses Problem. Features mit VIF-Werten über 10 sollten entfernt oder kombiniert werden.

## Fazit und Handlungsempfehlungen

Feature Engineering entscheidet in der Praxis häufiger über den Projekterfolg als die Modellauswahl. Für die Vorbereitung auf ein **feature engineering interview** gelten folgende Kernpunkte:

- **Skalierung an den Algorithmus anpassen**: Baumbasierte Modelle benötigen keine Skalierung, distanzbasierte Algorithmen schon. Diese Unterscheidung wird in Interviews gezielt abgefragt.
- **Encoding-Strategie nach Kardinalität wählen**: One-Hot für niedrige, Target Encoding für hohe Kardinalität. K-Fold Target Encoding verhindert Leakage.
- **Feature Selection systematisch durchführen**: Filter-Methoden zur Vorauswahl, Embedded-Methoden zur Feinauswahl. Immer im Kontext des Validierungsschemas evaluieren.
- **Zeitfeatures zyklisch codieren**: Sinus-Kosinus-Transformation für periodische Variablen nutzen, Lag- und Rolling-Features für Zeitreihenprognosen einsetzen.
- **Fehlende Werte als Information behandeln**: Indikator-Features erstellen, bevor imputiert wird. Die Imputationsmethode nach dem Fehlmechanismus wählen (MCAR, MAR, MNAR).
- **Pipelines nutzen**: Alle Transformationen in sklearn-Pipelines kapseln, um Data Leakage zu vermeiden und Reproduzierbarkeit sicherzustellen.

Wer diese Techniken sicher beherrscht und die zugrundeliegenden Konzepte erklären kann, ist für **data science interview questions** im Bereich Feature Engineering bestens vorbereitet.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/data-science/feature-engineering-machine-learning-techniques-interview-2026