Feature Engineering pour le Machine Learning : Techniques et Questions d'Entretien 2026

Le feature engineering constitue le socle sur lequel repose la performance de tout modele de machine learning. Les donnees brutes ne suffisent pratiquement jamais a alimenter un algorithme de maniere optimale : il faut les transformer, les encoder, les normaliser et selectionner les variables les plus pertinentes avant de lancer l'entrainement. En entretien technique de data science, les recruteurs evaluent systematiquement cette competence, car elle distingue un praticien capable de produire des modeles performants d'un candidat qui se contente d'appliquer des algorithmes sans reflexion prealable.

Ce guide couvre les techniques fondamentales du feature engineering, depuis l'encodage categoriel jusqu'aux pipelines de production, en passant par les methodes de selection automatisee. Chaque section inclut du code Python executable et les questions d'entretien les plus frequentes en 2026.

Strategies d'encodage categoriel

Les modeles de machine learning operent sur des valeurs numeriques. Toute variable categorielle doit donc etre convertie en representation numerique avant l'entrainement. Le choix de la methode d'encodage depend directement de la nature de la variable : ordinale ou nominale.

Une variable ordinale possede un ordre naturel (par exemple : petit, moyen, grand). Le LabelEncoder de scikit-learn lui attribue des entiers respectant cet ordre implicite. En revanche, une variable nominale comme une couleur n'a aucun ordre intrinseque. Utiliser un LabelEncoder dans ce cas introduirait une relation d'ordre artificielle que l'algorithme exploiterait a tort.

Le one-hot encoding resout ce probleme en creant une colonne binaire par categorie. Le parametre drop="first" supprime une colonne de reference pour eviter la multicolinearite parfaite, un piege classique avec les modeles lineaires.

# encoding_strategies.py
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

df = pd.DataFrame({
    "size": ["small", "medium", "large", "medium", "small"],
    "color": ["red", "blue", "green", "red", "blue"],
    "price": [10, 25, 40, 22, 12]
})

# Label encoding for ordinal feature (size has natural order)
le = LabelEncoder()
df["size_encoded"] = le.fit_transform(df["size"])  # large=0, medium=1, small=2

# One-hot encoding for nominal feature (color has no order)
ct = ColumnTransformer(
    transformers=[
        ("onehot", OneHotEncoder(drop="first", sparse_output=False), ["color"])
    ],
    remainder="passthrough"  # Keep other columns unchanged
)
result = ct.fit_transform(df[["color", "price"]])
# Produces: color_green, color_red columns (blue dropped as reference)

Au-dela de ces deux approches de base, le target encoding remplace chaque categorie par la moyenne de la variable cible pour cette categorie. Cette technique se revele particulierement efficace pour les variables a haute cardinalite (ville, code postal), ou le one-hot encoding genererait des centaines de colonnes creuses. Cependant, le target encoding necessite une regularisation ou un schema de cross-validation pour eviter le data leakage.

Feature scaling : StandardScaler, MinMaxScaler et RobustScaler

Le scaling des variables numeriques est indispensable pour les algorithmes bases sur la distance (KNN, SVM, regression logistique) et accelere la convergence des methodes a base de gradient. Trois approches principales existent, chacune avec ses compromis.

Le StandardScaler centre les donnees sur une moyenne de 0 et un ecart-type de 1. Il suppose une distribution approximativement gaussienne et reste sensible aux valeurs aberrantes, car la moyenne et l'ecart-type sont eux-memes affectes par les outliers.

Le MinMaxScaler projette les valeurs dans l'intervalle [0, 1]. Cette methode est encore plus sensible aux outliers : une seule valeur extreme ecrase la majorite des observations pres de zero.

Le RobustScaler utilise la mediane et l'ecart interquartile (IQR), deux statistiques resistantes aux valeurs aberrantes. Les donnees centrales conservent une repartition exploitable, tandis que les outliers sont isoles sans deformer l'ensemble du jeu de donnees.

# feature_scaling.py
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Simulated dataset: salary with outliers
data = np.array([[35000], [42000], [55000], [67000], [450000]])  # 450k is an outlier

# StandardScaler: mean=0, std=1 (sensitive to outliers)
standard = StandardScaler().fit_transform(data)
# Result: [-0.72, -0.68, -0.60, -0.53, 2.53] — outlier distorts the scale

# MinMaxScaler: maps to [0, 1] (very sensitive to outliers)
minmax = MinMaxScaler().fit_transform(data)
# Result: [0.0, 0.017, 0.048, 0.077, 1.0] — most values crushed near zero

# RobustScaler: uses median and IQR (robust to outliers)
robust = RobustScaler().fit_transform(data)
# Result: [-0.77, -0.5, 0.0, 0.46, 15.38] — outlier isolated, core data preserved

En entretien, la question classique porte sur le choix du scaler. La regle pratique : utiliser RobustScaler lorsque le jeu de donnees contient des outliers identifies, StandardScaler pour les distributions proches de la gaussienne, et MinMaxScaler uniquement lorsque l'algorithme exige explicitement des valeurs dans [0, 1] (reseaux de neurones avec activation sigmoide, par exemple). Pour approfondir les fondamentaux des algorithmes concernes, consulter le guide des algorithmes de machine learning.

Transformations mathematiques pour distributions asymetriques

Les distributions fortement asymetriques (right-skewed) posent probleme a de nombreux algorithmes, en particulier les modeles lineaires et les methodes qui supposent la normalite des residus. Les revenus, les montants de transactions et les durees de session suivent typiquement ce type de distribution.

La transformation logarithmique (log1p pour gerer les zeros) est la plus simple et souvent suffisante. La methode Box-Cox va plus loin en determinant automatiquement le parametre lambda optimal, mais exige des valeurs strictement positives. La methode Yeo-Johnson generalise Box-Cox en acceptant les valeurs nulles et negatives.

# skew_transformations.py
import numpy as np
from sklearn.preprocessing import PowerTransformer

# Right-skewed income data (common in real datasets)
income = np.array([[25000], [32000], [41000], [55000], [72000],
                   [150000], [320000], [890000]])

# Log transform: simple, effective for right-skewed data
log_income = np.log1p(income)  # log1p handles zero values safely

# Box-Cox: finds optimal power parameter automatically
pt = PowerTransformer(method="box-cox")  # Requires strictly positive values
income_boxcox = pt.fit_transform(income)
print(f"Optimal lambda: {pt.lambdas_[0]:.3f}")  # Shows learned parameter

# Yeo-Johnson: works with zero and negative values too
pt_yj = PowerTransformer(method="yeo-johnson")
income_yj = pt_yj.fit_transform(income)

Un point important a retenir pour les entretiens : la transformation doit etre appliquee sur le jeu d'entrainement, puis le meme objet transformateur doit etre utilise sur le jeu de test. Recalculer les parametres sur le jeu de test constitue un data leakage, une erreur que les recruteurs testent frequemment.

Methodes de selection de features

Avec des datasets contenant des dizaines ou des centaines de variables, la selection de features permet de reduire le bruit, d'accelerer l'entrainement et d'ameliorer la generalisation du modele. Trois grandes familles de methodes existent.

Les methodes filter evaluent chaque feature independamment du modele, via des tests statistiques (ANOVA F-test, chi-deux, information mutuelle). Elles sont rapides mais ignorent les interactions entre variables.

Les methodes wrapper evaluent des sous-ensembles de features en entrainant un modele a chaque iteration (forward selection, backward elimination). Elles capturent les interactions mais sont couteuses en calcul.

Les methodes embedded integrent la selection dans l'algorithme d'entrainement. La regularisation L1 (Lasso) met a zero les coefficients des variables non pertinentes, effectuant ainsi une selection automatique. Les modeles a base d'arbres fournissent des scores d'importance des features directement exploitables.

# feature_selection.py
from sklearn.datasets import make_classification
from sklearn.feature_selection import (
    SelectKBest, f_classif,  # Filter method
    SequentialFeatureSelector,  # Wrapper method
    SelectFromModel  # Embedded method
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LassoCV

# Dataset: 20 features, only 5 are informative
X, y = make_classification(
    n_samples=1000, n_features=20,
    n_informative=5, n_redundant=3, random_state=42
)

# Filter: ANOVA F-test selects top k features by statistical significance
selector_filter = SelectKBest(f_classif, k=8)
X_filtered = selector_filter.fit_transform(X, y)
print(f"Selected features: {selector_filter.get_support(indices=True)}")

# Embedded: L1 regularization (Lasso) zeros out irrelevant feature weights
lasso = LassoCV(cv=5, random_state=42).fit(X, y)
selector_embedded = SelectFromModel(lasso, prefit=True)
X_lasso = selector_embedded.transform(X)
print(f"Lasso kept {X_lasso.shape[1]} features out of {X.shape[1]}")

En pratique, une approche combinee donne les meilleurs resultats : commencer par un filtre rapide pour eliminer les variables manifestement inutiles, puis affiner avec une methode embedded. Pour une revision complete de l'ecosysteme Python en data science, le guide Python pour la data science constitue un complement indispensable.

Pipelines de production avec ColumnTransformer

En environnement de production, chaque etape de preprocessing doit etre encapsulee dans un pipeline scikit-learn. Cette approche offre trois avantages majeurs : elle elimine le data leakage lors de la cross-validation, garantit la reproductibilite des transformations entre entrainement et inference, et simplifie le deploiement.

Le ColumnTransformer permet d'appliquer des transformations differentes selon le type de colonne. Les variables numeriques passent par une imputation suivie d'un scaling, tandis que les variables categorielles sont imputees puis encodees. L'ensemble est chaine avec le modele dans un pipeline unique.

# production_pipeline.py
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

# Define column groups by type
numeric_features = ["age", "income", "credit_score"]
categorical_features = ["education", "employment_type", "region"]

# Numeric pipeline: impute missing values, then scale
numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),  # Median resists outliers
    ("scaler", StandardScaler())
])

# Categorical pipeline: impute missing, then one-hot encode
categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
])

# Combine into a single preprocessor
preprocessor = ColumnTransformer([
    ("num", numeric_pipeline, numeric_features),
    ("cat", categorical_pipeline, categorical_features)
])

# Full pipeline: preprocessing + model in one object
full_pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(n_estimators=200, random_state=42))
])

# Cross-validation applies preprocessing correctly within each fold
scores = cross_val_score(full_pipeline, X, y, cv=5, scoring="roc_auc")
print(f"AUC: {scores.mean():.3f} +/- {scores.std():.3f}")

Un point crucial que les recruteurs verifient : sans pipeline, le scaler est souvent ajuste (fit) sur l'ensemble du dataset avant la separation train/test. Le parametre cross_val_score avec un pipeline evite cette erreur en executant le fit uniquement sur chaque fold d'entrainement.

Feature engineering automatise avec Featuretools

Lorsque les donnees sont reparties sur plusieurs tables relationnelles, la creation manuelle de features d'agregation (nombre de transactions par client, montant moyen, ecart-type) devient fastidieuse et source d'erreurs. La bibliotheque Featuretools automatise ce processus via le Deep Feature Synthesis (DFS).

Le DFS parcourt les relations entre entites et applique systematiquement des primitives de transformation (extraction du mois, du jour de la semaine) et d'agregation (count, mean, std, max). Le parametre max_depth controle la complexite des features generees : une profondeur de 2 produit des features comme "ecart-type du montant des transactions de categorie alimentaire par client".

# automated_feature_engineering.py
import featuretools as ft
import pandas as pd

# Define entities from relational tables
customers = pd.DataFrame({
    "customer_id": [1, 2, 3],
    "signup_date": pd.to_datetime(["2024-01-15", "2024-03-22", "2024-06-01"]),
    "region": ["US", "EU", "APAC"]
})

transactions = pd.DataFrame({
    "txn_id": range(1, 8),
    "customer_id": [1, 1, 1, 2, 2, 3, 3],
    "amount": [50, 120, 30, 200, 85, 340, 15],
    "category": ["food", "tech", "food", "tech", "travel", "food", "tech"]
})

# Create an EntitySet with relationships
es = ft.EntitySet(id="retail")
es = es.add_dataframe(dataframe=customers, dataframe_name="customers",
                      index="customer_id", time_index="signup_date")
es = es.add_dataframe(dataframe=transactions, dataframe_name="transactions",
                      index="txn_id")
es = es.add_relationship("customers", "customer_id",
                         "transactions", "customer_id")

# DFS generates features: COUNT, MEAN, MAX, STD of transactions per customer
feature_matrix, feature_defs = ft.dfs(
    entityset=es, target_dataframe_name="customers",
    max_depth=2,  # Controls complexity of generated features
    trans_primitives=["month", "weekday"],  # Transformation primitives
    agg_primitives=["count", "mean", "std", "max"]  # Aggregation primitives
)
print(f"Generated {len(feature_defs)} features from 2 tables")

Featuretools se revele particulierement utile dans les domaines ou les donnees transactionnelles abondent : finance, e-commerce, telecoms. En entretien, la connaissance de cet outil demontre une capacite a industrialiser le feature engineering au-dela de l'approche manuelle.

Questions d'entretien frequentes sur le feature engineering

Les questions suivantes reviennent regulierement dans les entretiens data science en 2026. Pour chacune, les points cles que les recruteurs evaluent sont indiques.

Quelle est la difference entre le label encoding et le one-hot encoding ?

Le label encoding attribue un entier a chaque categorie et convient aux variables ordinales (taille, niveau d'education). Le one-hot encoding cree des colonnes binaires et convient aux variables nominales (couleur, pays). Utiliser le label encoding sur une variable nominale introduit un ordre artificiel que les algorithmes bases sur la distance exploiteront de maniere incorrecte.

Comment gerer les variables categorielles a haute cardinalite ?

Trois approches principales : le target encoding (remplacer chaque categorie par la moyenne de la cible, avec regularisation), le feature hashing (projeter les categories dans un espace de dimension fixe via une fonction de hash), et le regroupement (fusionner les categories rares dans une categorie "Autre"). Le choix depend du nombre de categories et du risque de data leakage.

Quand faut-il normaliser ou standardiser les features ?

La normalisation est necessaire pour les algorithmes sensibles a l'echelle des variables : KNN, SVM, regression logistique, reseaux de neurones. Les algorithmes a base d'arbres (Random Forest, XGBoost, LightGBM) sont invariants a l'echelle et ne necessitent pas de scaling. En cas de doute, standardiser ne nuit jamais a la performance.

Comment detecter et gerer le data leakage dans le feature engineering ?

Le data leakage survient lorsque des informations du jeu de test contaminent le processus d'entrainement. Les causes frequentes : ajuster un scaler sur l'ensemble du dataset avant la separation train/test, utiliser la variable cible pour creer des features (target encoding sans cross-validation), ou inclure des variables qui ne seraient pas disponibles au moment de la prediction en production. La parade : encapsuler tout le preprocessing dans un pipeline scikit-learn.

Comment aborder le feature engineering pour des donnees temporelles ?

Les donnees temporelles necessitent des features specifiques : composantes calendaires (jour de la semaine, mois, trimestre), lag features (valeur a t-1, t-7), rolling statistics (moyenne mobile sur 7 ou 30 jours), et features de tendance (difference premiere, taux de variation). L'erreur classique consiste a creer ces features avant la separation train/test, ce qui introduit un data leakage temporel.

Pour pratiquer ces questions avec des exercices interactifs, consulter les questions d'entretien sur le feature engineering.

Conclusion

Le feature engineering reste la competence la plus determinante pour la performance d'un modele de machine learning en 2026. Les points essentiels a retenir :

• Encodage categoriel : choisir entre label encoding (ordinal) et one-hot encoding (nominal), et connaitre les alternatives pour la haute cardinalite (target encoding, feature hashing)
• Feature scaling : adapter le choix du scaler a la distribution des donnees et a la presence d'outliers, en privilegiant RobustScaler pour les jeux de donnees bruites
• Transformations de distributions : appliquer log, Box-Cox ou Yeo-Johnson pour corriger l'asymetrie et ameliorer la performance des modeles lineaires
• Selection de features : combiner methodes filter (rapidite) et embedded (precision) pour reduire la dimensionnalite sans perdre d'information pertinente
• Pipelines de production : encapsuler systematiquement le preprocessing dans des pipelines scikit-learn pour eviter le data leakage et garantir la reproductibilite
• Feature engineering automatise : exploiter Featuretools et le DFS pour les schemas relationnels complexes, en controlant la profondeur pour eviter l'explosion combinatoire

La maitrise de ces techniques, associee a la capacite d'expliquer les compromis de chaque approche, constitue le socle attendu par les recruteurs en data science.