# Feature Engineering voor Machine Learning: Technieken en Interviewvragen 2026

> Leer de belangrijkste feature engineering technieken voor machine learning interviews. Met Python-voorbeelden en veelgestelde data science interviewvragen.

- 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 is het proces waarbij ruwe data wordt omgezet in betekenisvolle variabelen die de voorspelkracht van machine learning modellen aanzienlijk verbeteren. In een **feature engineering interview** wordt niet alleen theoretische kennis getoetst, maar ook het vermogen om creatieve en effectieve features te ontwerpen voor complexe datasets. Dit artikel behandelt de kernconcepten, praktische Python-implementaties en veelgestelde **data science interview questions** die in 2026 regelmatig terugkomen bij technische gesprekken.

> **Tip**
>
> Feature engineering bepaalt vaak het verschil tussen een middelmatig en een uitstekend presterend model. Recruiters en hiring managers hechten grote waarde aan kandidaten die niet alleen modellen kunnen trainen, maar ook weten hoe ze de juiste input daarvoor samenstellen.

## Waarom Feature Engineering Onmisbaar Is

Het succes van elk machine learning project hangt voor een groot deel af van de kwaliteit van de input-features. Zelfs het meest geavanceerde deep learning model levert ondermaatse resultaten op wanneer het wordt gevoed met slecht voorbereide data. **Machine learning feature engineering** omvat het selecteren, transformeren en creëren van variabelen die de onderliggende patronen in data beter vastleggen.

In de praktijk besteden data scientists vaak 60 tot 80 procent van hun tijd aan data voorbereiding en feature engineering. Dit is geen toeval: de juiste features reduceren ruis, voorkomen overfitting en maken modellen interpreteerbaarder. Tijdens een sollicitatiegesprek is het essentieel om dit proces helder te kunnen uitleggen en te demonstreren.

## Feature Scaling en Normalisatie

Veel machine learning algoritmen, waaronder gradient descent-gebaseerde modellen en afstandsgebaseerde methoden zoals k-NN, zijn gevoelig voor de schaal van inputvariabelen. Feature scaling zorgt ervoor dat alle variabelen op een vergelijkbare schaal opereren, waardoor het trainingsproces stabieler en sneller verloopt.

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

df = pd.DataFrame({
    "salary": [45000, 52000, 61000, 48000, 95000],
    "experience_years": [2, 4, 6, 3, 15],
    "age": [25, 30, 35, 28, 45]
})

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

# MinMaxScaler: waarden tussen 0 en 1
minmax_scaler = MinMaxScaler()
df_minmax = pd.DataFrame(
    minmax_scaler.fit_transform(df),
    columns=df.columns
)

# RobustScaler: robuust tegen uitschieters
robust_scaler = RobustScaler()
df_robust = pd.DataFrame(
    robust_scaler.fit_transform(df),
    columns=df.columns
)

print("StandardScaler resultaat:")
print(df_standard.round(3))
```

De keuze tussen deze methoden hangt af van de verdeling van de data. StandardScaler is geschikt voor normaal verdeelde variabelen, MinMaxScaler voor bounded features, en RobustScaler wanneer de dataset uitschieters bevat. Een veelgestelde interviewvraag is wanneer welke methode de voorkeur verdient — het antwoord draait altijd om de eigenschappen van de specifieke dataset.

## Categorische Variabelen Coderen

Categorische variabelen vormen een bijzondere uitdaging omdat de meeste algoritmen uitsluitend met numerieke input werken. De wijze waarop deze variabelen worden gecodeerd, heeft directe invloed op modelprestaties. Er bestaan verschillende strategieën, elk met eigen voor- en nadelen.

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

df = pd.DataFrame({
    "city": ["Amsterdam", "Rotterdam", "Utrecht", "Amsterdam", "Den Haag"],
    "education": ["HBO", "WO", "MBO", "WO", "HBO"],
    "salary": [55000, 62000, 41000, 68000, 52000]
})

# One-Hot Encoding: voor nominale variabelen zonder ordening
df_onehot = pd.get_dummies(df, columns=["city"], prefix="city")

# Ordinal Encoding: voor variabelen met natuurlijke ordening
education_order = [["MBO", "HBO", "WO"]]
ordinal_enc = OrdinalEncoder(categories=education_order)
df["education_encoded"] = ordinal_enc.fit_transform(df[["education"]])

# Target Encoding: gemiddelde van de doelvariabele per categorie
target_enc = TargetEncoder(cols=["city"], smoothing=2)
df["city_target_encoded"] = target_enc.fit_transform(
    df["city"], df["salary"]
)

print("One-Hot Encoded:")
print(df_onehot.head())
print("\nOrdinal + Target Encoded:")
print(df[["city", "education_encoded", "city_target_encoded"]])
```

One-hot encoding is de veiligste keuze voor variabelen met weinig unieke waarden, maar leidt tot dimensie-explosie bij hoge cardinaliteit. Target encoding is in dat geval een krachtig alternatief, mits het correct wordt toegepast met kruisvalidatie om data leakage te voorkomen. Dit onderscheid is een klassiek onderwerp bij **data science interview questions**.

## Feature Selection Technieken

Niet elke feature draagt bij aan de voorspelkracht van een model. Irrelevante of redundante variabelen introduceren ruis en verhogen de kans op overfitting. **Feature selection techniques** helpen bij het identificeren van de meest informatieve subset van variabelen.

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

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

# Filter methode: statistische tests
selector_anova = SelectKBest(score_func=f_classif, k=10)
X_filtered = selector_anova.fit_transform(X, y)
anova_scores = pd.Series(
    selector_anova.scores_, index=feature_names
).sort_values(ascending=False)
print("ANOVA F-scores (top 10):")
print(anova_scores.head(10))

# Mutual Information: vangt ook niet-lineaire relaties
selector_mi = SelectKBest(score_func=mutual_info_classif, k=10)
selector_mi.fit(X, y)
mi_scores = pd.Series(
    selector_mi.scores_, index=feature_names
).sort_values(ascending=False)

# Wrapper methode: Recursive Feature Elimination
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rfe = RFE(estimator=rf_model, n_features_to_select=10, step=2)
rfe.fit(X, y)
selected_features = [f for f, s in zip(feature_names, rfe.support_) if s]
print(f"\nRFE geselecteerde features: {selected_features}")
```

Filter-methoden zoals ANOVA en mutual information zijn snel maar houden geen rekening met interacties tussen features. Wrapper-methoden zoals RFE zijn nauwkeuriger maar computationeel duurder. Embedded methoden, zoals de ingebouwde feature importance van Random Forest of L1-regularisatie, bieden een goed compromis. Tijdens een interview is het waardevol om alle drie de categorieën te kunnen benoemen en hun afwegingen te bespreken.

## Interactie-Features Creëren

Soms ligt de voorspelkracht niet in individuele variabelen maar in de combinatie ervan. Interactie-features leggen relaties vast die een model anders niet zou ontdekken, vooral bij lineaire modellen die geen automatische interactie-detectie uitvoeren.

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

df = pd.DataFrame({
    "length": [5.2, 3.8, 7.1, 4.5, 6.3],
    "width": [2.1, 1.9, 3.4, 2.0, 2.8],
    "height": [1.5, 1.2, 2.0, 1.3, 1.7]
})

# Handmatige interactie-features
df["volume"] = df["length"] * df["width"] * df["height"]
df["area"] = df["length"] * df["width"]
df["length_width_ratio"] = df["length"] / df["width"]
df["surface_density"] = df["height"] / df["area"]

# PolynomialFeatures voor systematische interacties
poly = PolynomialFeatures(
    degree=2,
    interaction_only=True,
    include_bias=False
)
X_poly = poly.fit_transform(df[["length", "width", "height"]])
poly_names = poly.get_feature_names_out(["length", "width", "height"])

df_interactions = pd.DataFrame(X_poly, columns=poly_names)
print("Gegenereerde interactie-features:")
print(df_interactions.head())

# Domeinspecifieke ratio-features
df["aspect_ratio"] = df["length"] / df["height"]
df["compactness"] = df["volume"] / (df["length"] ** 3)
print("\nDataset met alle features:")
print(df.round(3))
```

Het verschil tussen een junior en een senior data scientist wordt vaak zichtbaar in de kwaliteit van handmatig ontworpen features. Domeinkennis speelt hierbij een cruciale rol: wie de onderliggende businesslogica begrijpt, kan features creëren die een zuiver algoritmische aanpak mist. Bij een **feature engineering interview** wordt deze vaardigheid actief getoetst.

## Omgaan met Ontbrekende Waarden

Ontbrekende waarden komen in vrijwel elke productiedataset voor. De strategie voor het afhandelen ervan heeft directe impact op modelkwaliteit. Het simpelweg verwijderen van rijen met missende waarden is zelden de beste aanpak, vooral wanneer het patroon van ontbrekende data zelf informatief is.

```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

df = pd.DataFrame({
    "age": [25, np.nan, 35, 40, np.nan, 55],
    "income": [45000, 52000, np.nan, 68000, 41000, np.nan],
    "score": [7.5, 8.0, 6.5, np.nan, 7.0, 9.0],
    "category": ["A", "B", np.nan, "A", "C", "B"]
})

# Indicatorvariabelen: ontbrekend als feature
for col in ["age", "income", "score"]:
    df[f"{col}_missing"] = df[col].isna().astype(int)

# Numerieke imputatie met KNN
knn_imputer = KNNImputer(n_neighbors=3, weights="distance")
numeric_cols = ["age", "income", "score"]
df[numeric_cols] = knn_imputer.fit_transform(df[numeric_cols])

# Iteratieve imputatie (MICE-achtig)
iterative_imputer = IterativeImputer(
    max_iter=20, random_state=42
)
df_iterative = pd.DataFrame(
    iterative_imputer.fit_transform(df[numeric_cols]),
    columns=numeric_cols
)

# Categorische imputatie: modus of aparte categorie
df["category"] = df["category"].fillna("Unknown")

print("Geïmputeerde dataset:")
print(df.round(2))
print(f"\nMissing indicator kolommen: {[c for c in df.columns if '_missing' in c]}")
```

Het toevoegen van missingness-indicatoren als aparte features is een techniek die tijdens interviews vaak het verschil maakt. Het patroon van ontbrekende data kan zelf voorspellende waarde bevatten — bijvoorbeeld wanneer gebruikers bewust bepaalde velden leeg laten. KNN-imputatie en iteratieve imputatie leveren doorgaans betere resultaten dan simpele gemiddelde-imputatie, omdat ze de correlaties tussen variabelen meenemen.

## Tijdgebaseerde Feature Engineering

Tijdreeksdata vereist specifieke feature engineering technieken die temporele patronen vastleggen. Van seizoensgebonden trends tot rolling statistics: het extraheren van tijdsinformatie is een veelvoorkomend onderwerp in **machine learning feature engineering** interviews.

```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({
    "date": dates,
    "sales": np.random.poisson(lam=50, size=365) + \
             (np.sin(np.arange(365) * 2 * np.pi / 7) * 10).astype(int)
})

# Kalender-features extraheren
df["day_of_week"] = df["date"].dt.dayofweek
df["month"] = df["date"].dt.month
df["quarter"] = df["date"].dt.quarter
df["is_weekend"] = (df["day_of_week"] >= 5).astype(int)
df["day_of_year"] = df["date"].dt.dayofyear

# Cyclische codering voor periodieke features
df["month_sin"] = np.sin(2 * np.pi * df["month"] / 12)
df["month_cos"] = np.cos(2 * np.pi * df["month"] / 12)
df["dow_sin"] = np.sin(2 * np.pi * df["day_of_week"] / 7)
df["dow_cos"] = np.cos(2 * np.pi * df["day_of_week"] / 7)

# Rolling statistics: voortschrijdende vensters
df["sales_rolling_7d"] = df["sales"].rolling(window=7).mean()
df["sales_rolling_30d"] = df["sales"].rolling(window=30).mean()
df["sales_rolling_std_7d"] = df["sales"].rolling(window=7).std()

# Lag-features: waarden uit het verleden
for lag in [1, 7, 14, 28]:
    df[f"sales_lag_{lag}"] = df["sales"].shift(lag)

# Verschil-features
df["sales_diff_1d"] = df["sales"].diff(1)
df["sales_diff_7d"] = df["sales"].diff(7)

# Expanding (cumulatieve) statistieken
df["sales_expanding_mean"] = df["sales"].expanding().mean()

print("Tijdgebaseerde features (eerste 35 rijen):")
print(df.iloc[30:35][["date", "sales", "sales_rolling_7d",
                        "sales_lag_7", "month_sin"]].round(3))
```

Cyclische codering met sinus- en cosinustransformaties voorkomt dat het model onterechte afstanden leert — maand 12 en maand 1 liggen in werkelijkheid naast elkaar, maar als integers zijn ze ver verwijderd. Lag-features en rolling statistics geven het model geheugen over het verleden, wat essentieel is voor nauwkeurige tijdreeksvoorspellingen.

## Veelgestelde Interviewvragen over Feature Engineering

Ter voorbereiding op een **feature engineering interview** is het nuttig om de meest voorkomende vragen en verwachte antwoorden te kennen:

**Wat is het verschil tussen feature selection en feature extraction?** Feature selection kiest een subset uit bestaande features, terwijl feature extraction nieuwe features creëert door transformaties toe te passen (zoals PCA). Beide verminderen dimensionaliteit maar op fundamenteel verschillende manieren.

**Hoe voorkom je data leakage bij feature engineering?** Alle transformaties worden uitsluitend op trainingsdata gefit en vervolgens op test- en validatiedata getransformeerd. Pipelines in scikit-learn garanderen deze scheiding. Target encoding vereist extra aandacht en wordt idealiter met cross-validation binnen de trainingsset uitgevoerd.

**Wanneer kies je voor one-hot encoding versus target encoding?** One-hot encoding is veilig bij lage cardinaliteit (minder dan 15-20 unieke waarden). Bij hogere cardinaliteit leidt one-hot encoding tot een explosie van dimensies en is target encoding of embedding-gebaseerde encoding effectiever.

**Hoe ga je om met features die een hoge correlatie vertonen?** Sterk gecorreleerde features verwijderen verbetert modelstabiliteit en interpreteerbaarheid. Variance Inflation Factor (VIF) en correlatiematrices zijn standaardtools voor het opsporen van multicollineariteit.

## Conclusie

Feature engineering blijft in 2026 een van de meest gewaardeerde vaardigheden in data science. De combinatie van technische implementatiekennis en domeinbegrip onderscheidt sterke kandidaten in het sollicitatieproces. De belangrijkste takeaways voor een succesvolle voorbereiding:

- Beheers de verschillende scalingsmethoden en weet wanneer welke van toepassing is op basis van dataverdeling en algoritme-eisen.
- Kies de juiste encodingstrategie voor categorische variabelen, met speciale aandacht voor data leakage bij target encoding.
- Combineer filter-, wrapper- en embedded-methoden voor robuuste **feature selection techniques** die zowel efficiënt als nauwkeurig zijn.
- Behandel ontbrekende waarden als informatiebron door missingness-indicatoren toe te voegen naast imputatie.
- Pas cyclische codering en lag-features toe voor tijdreeksdata om temporele patronen volledig vast te leggen.
- Oefen het uitleggen van ontwerpkeuzes — interviewers waarderen een helder verhaal minstens zo veel als correcte code.

---

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