Comment automatiser le feature engineering en Python efficacement ?

Automatiser le feature engineering en Python est possible grâce à des scripts ciblés qui simplifient l’encodage, la transformation, et la sélection de variables. Découvrez 5 scripts puissants pour booster vos modèles sans perdre de temps ni précision.

3 principaux points à retenir.

Automatisation ciblée : scripts dédiés pour chaque étape clé du feature engineering.
Optimisation des performances : transformation et sélection des features basées sur des critères robustes.
Consistance et robustesse : gestion intelligente des catégories rares, outliers, et données temporelles.

Comment gérer efficacement les variables catégorielles ?

L’encodage automatique des variables catégorielles est essentiel pour éviter les erreurs courantes et optimiser l’utilisation de la mémoire. Dans le monde des données, ces variables sont omniprésentes. Mais comment les traiter efficacement ? Le choix de la méthode d’encodage est crucial et dépend de deux facteurs clés : la cardinalité de la variable et sa corrélation avec la cible.

One-hot encoding : Idéal pour les variables à faible cardinalité. Par exemple, si vous avez une variable « couleur » avec des valeurs comme « rouge », « bleu », « vert », cette méthode crée une colonne binaire pour chaque couleur. Cependant, attention à la dimensionnalité qui peut exploser avec trop de catégories.
Frequency encoding : Pratique pour les variables à haute cardinalité. Ici, chaque catégorie est remplacée par la fréquence de son apparition dans le jeu de données. Cela aide à éviter le problème de dimensionnalité tout en préservant l’information.
Target encoding : Utilisé pour les variables qui montrent une corrélation avec la cible. Cette méthode remplace chaque catégorie par la moyenne de la cible pour cette catégorie, mais attention aux fuites de données, il faut bien gérer votre validation.
Label encoding : Parfait pour les variables ordinales où l’ordre est significatif, comme « petit », « moyen », « grand ». Chaque catégorie est attribuée un entier, ce qui peut induire une ordonnancement implicite.

Il est également crucial de gérer les catégories rares et inconnues, surtout dans le jeu de test. Par exemple, si une catégorie apparaît dans le jeu de test mais pas dans le jeu d’entraînement, il est sage de la regrouper dans une catégorie « autre » ou de la traiter avec une valeur par défaut. De plus, maintenir la cohérence entre les jeux d’entraînement, de validation et de test est vital pour éviter des résultats biaisés.

Voici un exemple de code Python simple illustrant l’encodage ciblé :

import pandas as pd
from category_encoders import TargetEncoder

# Exemple de DataFrame
data = {'couleur': ['rouge', 'bleu', 'vert', 'rouge', 'bleu'],
        'valeur': [10, 20, 15, 25, 30]}
df = pd.DataFrame(data)

# Application de l'encodage ciblé
encoder = TargetEncoder(cols=['couleur'])
df['couleur_encoded'] = encoder.fit_transform(df['couleur'], df['valeur'])
print(df)

Pour récapituler, il est essentiel de choisir la bonne méthode d’encodage en fonction de vos données. Vous pouvez consulter plus d’informations sur le feature engineering pour approfondir ce sujet. Voici un tableau synthétique des méthodes d’encodage selon les cas d’usage :

Méthode	Type de variable	Utilisation
One-hot encoding	Faible cardinalité	Catégories distinctes
Frequency encoding	Haute cardinalité	Catégories nombreuses
Target encoding	Corrélée avec la cible	Éviter la fuite de données
Label encoding	Ordinales	Ordre significatif

Quelles transformations appliquer aux variables numériques ?

Les variables numériques, ces petites merveilles de la donnée, nécessitent souvent des transformations pour optimiser vos modèles. Pourquoi ? Parce que des distributions biaisées (ou skewed) et des valeurs aberrantes (outliers) peuvent sérieusement compromettre la performance de vos algorithmes. L’idée ici, c’est de nettoyer et d’ajuster ces données pour qu’elles soient prêtes à être utilisées. Voici quelques transformations automatisées qui peuvent faire la différence :

Logarithmique : Idéal pour réduire la skewness. Attention, cela ne fonctionne qu’avec des valeurs positives.
Box-Cox : Une transformation polyvalente qui s’ajuste à la distribution des données. Pratique, mais nécessite des valeurs positives.
Racine carrée : Utile pour des distributions légèrement skewed.
Standardisation : Ramène vos données à une moyenne de 0 et un écart-type de 1, parfait pour les modèles sensibles à l’échelle.
Normalisation : Fait passer vos valeurs entre 0 et 1. Pratique pour les réseaux de neurones.
Robust Scaling : Résistant aux outliers, il utilise les quantiles pour centrer et réduire les données.
Yeo-Johnson : Comme Box-Cox, mais il fonctionne avec des valeurs négatives, ce qui est un vrai plus.

Mais comment savoir quelle transformation appliquer ? C’est là que les tests de normalité entrent en jeu. Des méthodes comme Shapiro-Wilk et Anderson-Darling vous aident à évaluer si vos données sont normales. Vous pouvez également examiner des métriques de distribution comme la skewness et la kurtosis pour affiner votre choix.

Voici un exemple de code Python qui teste ces transformations :


import pandas as pd
import numpy as np
from scipy import stats

# Exemple de données
data = pd.Series(np.random.exponential(scale=2.0, size=1000))

# Transformation log
log_data = np.log(data[data > 0])

# Test de normalité
shapiro_test = stats.shapiro(log_data)
anderson_test = stats.anderson(log_data)

print("Shapiro-Wilk Test:", shapiro_test)
print("Anderson-Darling Test:", anderson_test)

Pour finir, voici un tableau comparatif des transformations selon les profils de données :

Transformation	Type de distribution	Gestion des outliers
Logarithmique	Droite	Non
Box-Cox	Flexible	Non
Racine carrée	Légèrement skewed	Non
Standardisation	Tout type	Non
Normalisation	Tout type	Non
Robust Scaling	Tout type	Oui
Yeo-Johnson	Tout type	Non

Pour explorer plus en profondeur les transformations de données, vous pouvez consulter ce lien ici.

Comment générer et sélectionner les interactions de features pertinentes ?

Les interactions entre features sont souvent la clé pour déceler des signaux cachés qui échappent à une analyse classique. Par exemple, imaginez que le revenu d’un client n’est pas seulement influencé par son âge, mais aussi par la combinaison de son âge et de son statut marital. Cependant, générer toutes les combinaisons possibles de features peut rapidement devenir coûteux, tant en termes de temps que de ressources.

Pour faciliter cette tâche, nous avons un script qui automatise la création d’interactions entre features. Ce script génère des interactions numériques telles que des produits, des ratios, des sommes et des différences, ainsi que des interactions catégorielles, en combinant les catégories de différentes features. Ensuite, il évalue l’utilité de chaque interaction à l’aide de méthodes telles que l’information mutuelle ou les scores d’importance issus de modèles.

La sélection des meilleures interactions se fait selon un seuil défini ou en conservant un top N des interactions les plus pertinentes. Ce processus prend en compte des cas particuliers, comme la division par zéro ou les valeurs infinies, garantissant ainsi une robustesse dans les résultats.

Voici un exemple de code qui illustre comment générer et filtrer ces interactions :


import pandas as pd
from sklearn.feature_selection import mutual_info_regression
from itertools import combinations

# Exemple de DataFrame
data = pd.DataFrame({
    'feature1': [1, 2, 3, 4],
    'feature2': [5, 6, 7, 8],
    'target': [1, 2, 3, 4]
})

# Génération des interactions
def generate_interactions(df):
    interactions = {}
    for (col1, col2) in combinations(df.columns[:-1], 2):
        interactions[f'{col1}_*_{col2}'] = df[col1] * df[col2]
        interactions[f'{col1}_/_ {col2}'] = df[col1] / df[col2].replace(0, 1e-9)  # éviter division par zéro
    return pd.DataFrame(interactions)

# Filtrer les interactions
def filter_interactions(df, target):
    X = df.drop(columns=[target])
    y = df[target]
    mi = mutual_info_regression(X, y)
    return X.columns[mi > 0.1]  # seuil arbitraire

# Utilisation
interactions_df = generate_interactions(data)
selected_interactions = filter_interactions(interactions_df, 'target')
print(selected_interactions)

Pour résumer, ce script permet d’explorer les interactions entre features de manière systématique, tout en évaluant leur pertinence. Cela vous permet de ne conserver que les combinaisons les plus prometteuses, optimisant ainsi votre modèle sans vous perdre dans un océan de données inutiles.

Type d’interaction	Méthode de scoring
Produits	Information mutuelle
Ratios	Importance modèle
Sommes	Information mutuelle
Différences	Importance modèle

Pourquoi et comment extraire automatiquement les features temporelles ?

Les données datetime sont souvent sous-exploitées dans les projets de machine learning. Pourtant, elles recèlent des patterns essentiels qui peuvent transformer des modèles ordinaires en véritables machines prédictives. Pourquoi ? Parce que chaque instant dans le temps peut révéler des informations cachées, comme des tendances saisonnières ou des comportements récurrents. L’extraction automatique des composants de date/heure est donc une étape incontournable.

Commençons par les éléments de base : l’année, le mois, le jour et l’heure. Ces informations permettent de créer des indicateurs calendaires comme les weekends ou les jours fériés, qui peuvent influencer le comportement des utilisateurs. Par exemple, les ventes peuvent exploser pendant les fêtes, mais stagner les dimanches. En utilisant des encodages cycliques avec des transformations sinus et cosinus, vous pouvez gérer la circularité des cycles temporels. Cela signifie que décembre et janvier ne seront pas traités comme des mois disjoints, mais comme des points proches dans un cycle annuel.

De plus, il est crucial d’analyser les différences temporelles entre colonnes. Par exemple, le temps écoulé entre la date de commande et la date d’expédition peut fournir des insights précieux sur l’efficacité d’un processus. Ces features enrichissent votre modèle en ajoutant des dimensions temporelles qui sont souvent négligées.

Voici un exemple de code Python qui montre comment extraire ces features temporelles de manière automatisée :


import pandas as pd
import numpy as np

# Exemple de DataFrame avec une colonne datetime
df = pd.DataFrame({
    'timestamp': pd.to_datetime(['2023-01-01 12:30', '2023-02-14 15:45', '2023-03-01 09:00'])
})

# Extraction des composants de date/heure
df['year'] = df['timestamp'].dt.year
df['month'] = df['timestamp'].dt.month
df['day'] = df['timestamp'].dt.day
df['hour'] = df['timestamp'].dt.hour
df['weekday'] = df['timestamp'].dt.weekday
df['is_weekend'] = np.where(df['weekday'] >= 5, 1, 0)

# Encodage cyclique
df['month_sin'] = np.sin(2 * np.pi * df['month']/12)
df['month_cos'] = np.cos(2 * np.pi * df['month']/12)

# Affichage du DataFrame enrichi
print(df)

Ce code permet d’extraire des features classiques et de les transformer en informations exploitables. Voici un tableau récapitulatif des features temporelles extraites et leur intérêt :

Feature	Intérêt
year	Analyse des tendances sur plusieurs années
month	Identification des tendances saisonnières
day	Analyse des comportements quotidiens
hour	Compréhension des variations horaires
is_weekend	Impact sur les ventes et l’engagement
month_sin, month_cos	Gestion de la circularité des mois

En intégrant ces features dans vos modèles, vous augmenterez leur puissance prédictive. Pour aller plus loin dans le feature engineering, vous pouvez consulter des ressources comme ce lien.

Comment sélectionner automatiquement les meilleures features ?

La sélection automatique des features est un passage obligé pour éviter le surapprentissage et réduire la dimensionnalité de vos modèles. En gros, vous ne voulez pas noyer votre algorithme avec des variables inutiles qui pourraient le rendre moins performant. Alors, comment procéder efficacement ?

Commencez par une pipeline multi-étapes. Voici comment cela fonctionne :

Suppression des variables à faible variance : Les features qui n’apportent aucune information (celles qui restent constantes ou quasi constantes) doivent être éliminées dès le départ.
Élimination des features fortement corrélées : Si deux variables sont très corrélées, l’une d’elles peut souvent être retirée sans perdre d’information. Cela aide à réduire la redondance.
Utilisation de tests statistiques : Faites appel à des tests comme l’ANOVA, le chi carré ou l’information mutuelle pour évaluer l’importance des features par rapport à la cible.
Importance via arbres : Utilisez des modèles basés sur des arbres (comme les forêts aléatoires) pour obtenir des scores d’importance des features.
Régularisation L1 : Cette méthode aide à réduire le nombre de features en pénalisant les coefficients des variables moins pertinentes.
Élimination récursive : Cela implique de construire un modèle et de retirer les features les moins importantes, puis de répéter le processus jusqu’à atteindre un ensemble optimal.

Une fois ces étapes réalisées, combinez les scores d’importance provenant des différentes méthodes pour obtenir un classement final des features. Cela vous permettra de déterminer quel sous-ensemble de variables maximise la performance du modèle tout en minimisant la dimensionnalité.

Voici un exemple de code Python qui illustre cette approche :


from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.feature_selection import mutual_info_classif
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Charger les données
data = load_iris()
X, y = data.data, data.target

# Séparer les données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Pipeline de sélection de features
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('feature_selection', SelectFromModel(RandomForestClassifier(n_estimators=100))),
])

# Ajuster le modèle
pipeline.fit(X_train, y_train)

# Sélectionner les features
selected_features = pipeline.named_steps['feature_selection'].get_support(indices=True)
print("Features sélectionnées :", selected_features)

Ce code montre comment construire une pipeline simple pour sélectionner automatiquement les meilleures features. En combinant les différentes méthodes, vous pouvez obtenir un modèle robuste qui s’adapte bien à vos données.

Pour approfondir le sujet du feature engineering, n’hésitez pas à consulter ce tutoriel qui offre des insights précieux.

Prêt à automatiser votre feature engineering pour des modèles plus performants ?

Automatiser le feature engineering avec ces cinq scripts Python, c’est s’assurer de ne rien manquer d’essentiel tout en gagnant un temps précieux. De l’encodage intelligent des variables catégorielles à la sélection rigoureuse des meilleures features, chaque script apporte une brique solide pour construire des modèles plus précis et fiables. En adoptant cette approche systématique, vous transformez un travail fastidieux en un processus fluide et reproductible, un vrai atout pour vos projets machine learning.

FAQ

Comment choisir la meilleure méthode d’encodage pour une variable catégorielle ?

La méthode dépend de la cardinalité de la variable et de sa corrélation avec la cible. Pour peu de catégories, privilégiez le one-hot encoding. Pour beaucoup, préférez le frequency encoding. Si la variable est corrélée à la cible, le target encoding avec lissage est recommandé.

Comment gérer les outliers lors des transformations numériques ?

Les outliers sont gérés via des méthodes robustes comme le robust scaling qui utilise la médiane et les quartiles, limitant leur influence. Les transformations comme Yeo-Johnson permettent également de traiter les valeurs extrêmes sans erreur.

Quelles interactions de features sont les plus utiles ?

Les interactions numériques comme produits et ratios sont souvent riches en information, ainsi que les combinaisons catégorielles. La sélection via mutual information ou importance modèle permet de retenir uniquement les interactions réellement pertinentes.

Pourquoi utiliser un encodage cyclique pour les features temporelles ?

Les encodages sinus et cosinus permettent de représenter la circularité des cycles temporels (heures, mois), évitant que décembre et janvier soient perçus comme éloignés, ce qui améliore la capture des patterns saisonniers.

Comment s’assurer que la sélection automatique de features est fiable ?

La fiabilité vient de l’utilisation combinée de plusieurs méthodes (statistiques, modèles, régularisation) et de la validation croisée pour éviter le surapprentissage et garantir que les features retenues améliorent vraiment la performance.

A propos de l’auteur

Franck Scandolera, expert en Analytics, Data et Automatisation IA, accompagne depuis plus de 10 ans les entreprises dans l’intégration de l’intelligence artificielle et l’optimisation des workflows métier. Consultant et formateur reconnu, il partage ses expériences concrètes en développement d’applications IA et feature engineering pour rendre la data science accessible et efficace.

Franck Scandolera

⭐ Expert et formateur en Tracking avancé, Analytics Engineering et Automatisation IA (n8n, Make) ⭐

Ref clients : Logis Hôtel, Yelloh Village, BazarChic, Fédération Football Français, Texdecor…

Mon terrain de jeu :

Data & Analytics engineering : tracking propre RGPD, entrepôt de données (GTM server, BigQuery…), modèles (dbt/Dataform), dashboards décisionnels (Looker, SQL, Python).
Automatisation IA des taches Data, Marketing, RH, compta etc : conception de workflows intelligents robustes (n8n, Make, App Script, scraping) connectés aux API de vos outils et LLM (OpenAI, Mistral, Claude…).
Engineering IA pour créer des applications et agent IA sur mesure : intégration de LLM (OpenAI, Mistral…), RAG, assistants métier, génération de documents complexes, APIs, backends Node.js/Python.