Comment automatiser efficacement le feature engineering en Python ?

Le feature engineering automatisé en Python optimise la création de variables pertinentes, boostant vos modèles sans perdre de temps. Découvrez 5 scripts clés pour coder, transformer, interagir, extraire et sélectionner vos features avec rigueur et agilité.

3 principaux points à retenir.

• Automatisez l’encodage des variables catégorielles pour gérer cardinalités et éviter les pièges du target leakage.
• Transformez intelligemment les variables numériques avec tests de normalité et traitements adaptés aux outliers.
• Générez et sélectionnez automatiquement interactions et features clés pour maximiser la performance modèle.

Comment encoder automatiquement les variables catégorielles ?

L’encodage automatique des variables catégorielles est une étape cruciale dans le feature engineering, car il permet d’optimiser la gestion des cardinalités tout en évitant des erreurs courantes comme le target leakage. La sélection de la méthode d’encodage appropriée dépend du type et de la fréquence des catégories présentes dans votre jeu de données.

• One-hot encoding : Idéal pour les variables à faible cardinalité (moins de 10 catégories). Cette méthode crée une colonne binaire pour chaque catégorie, mais attention, elle peut engendrer un problème de dimensionnalité avec des catégories nombreuses.
• Target encoding : Pratique pour les variables ayant une forte corrélation avec la cible. Elle remplace chaque catégorie par la moyenne de la cible pour cette catégorie, mais elle doit être utilisée avec précaution pour éviter le leakage.
• Frequency encoding : À utiliser pour les variables à haute cardinalité (plus de 50 catégories). Elle remplace chaque catégorie par sa fréquence d’apparition, ce qui réduit la dimensionnalité sans perdre d’information.
• Label encoding : Adapté aux variables ordinales, où l’ordre a de l’importance. Cette méthode attribue un nombre entier à chaque catégorie, mais attention à ne pas l’appliquer à des variables nominales, car cela pourrait induire des relations trompeuses.

Pour gérer les catégories rares et inconnues dans les données de test, il est essentiel de regrouper les catégories peu fréquentes dans une catégorie « autre » ou d’utiliser une stratégie par défaut qui attribue la moyenne globale pour le target encoding.

Voici un exemple de code Python simple utilisant pandas et sklearn pour un encodage intelligent :

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Exemple de données
data = pd.DataFrame({'category': ['A', 'B', 'A', 'C', 'B', 'D', 'C', 'A', 'E']})

# One-hot encoding
ohe = OneHotEncoder(sparse=False)
one_hot_encoded = ohe.fit_transform(data[['category']])
one_hot_df = pd.DataFrame(one_hot_encoded, columns=ohe.get_feature_names_out(['category']))

# Label encoding
le = LabelEncoder()
data['category_encoded'] = le.fit_transform(data['category'])

print(one_hot_df)
print(data)

Découvrez égalementComment prétraiter les données en Python en 8 astuces ?

Avec cela, vous pouvez facilement encoder vos variables catégorielles de manière efficace et éviter les pièges classiques du feature engineering. Pour plus de détails sur les techniques d’encodage, consultez cette ressource.

Comment transformer efficacement les variables numériques ?

La transformation automatique des variables numériques est un enjeu crucial en machine learning. Pourquoi ? Parce qu’elle corrige les distributions, réduit l’impact des outliers et prépare vos données pour les modèles. En gros, sans transformation adéquate, vos résultats risquent d’être biaisés, et vous ne voulez pas ça, n’est-ce pas ?

Dans ce contexte, plusieurs transformations peuvent être envisagées. Voici celles que vous devez connaître :

• Logarithmique : Utile pour réduire l’asymétrie des distributions. Elle est efficace pour les variables positives.
• Box-Cox : Une transformation puissante qui nécessite des valeurs positives. Elle permet de stabiliser la variance.
• Racine carrée : Idéale pour atténuer les effets des valeurs extrêmes, surtout pour des données comptables.
• Standardisation : Z-score, qui centre et réduit les données, est parfait pour les algorithmes sensibles à l’échelle.
• Robust Scaling : Cette méthode est moins affectée par les outliers et utilise les quartiles pour la transformation.
• Yeo-Johnson : Semblable à Box-Cox, mais fonctionne avec des valeurs négatives et nulles, ce qui est un vrai plus.

Alors, comment choisir la transformation optimale ? C’est là que les tests de normalité entrent en jeu. Des tests comme Shapiro-Wilk et Anderson-Darling vous permettent de mesurer si la transformation améliore la normalité de la distribution. Pour les valeurs négatives ou nulles, des solutions comme le décalage ou les transformations Yeo-Johnson sont à envisager.

Découvrez égalementComment 5 containers Docker transforment votre PME ?

Voici un exemple de script Python pour sélectionner et appliquer la transformation optimale :

import pandas as pd
from scipy import stats

def transform_numerical_features(df):
    for col in df.select_dtypes(include=['float64', 'int64']).columns:
        stat, p = stats.shapiro(df[col])
        if p < 0.05:  # Non-normal
            df[col] = stats.boxcox(df[col] + 1)[0]  # Box-Cox avec décalage
    return df

data = pd.DataFrame({'values': [1, 2, 3, 4, 5, 100]})
transformed_data = transform_numerical_features(data)
print(transformed_data)

Pour résumer les transformations et leurs usages, voici un tableau comparatif :

Pour approfondir vos connaissances sur le sujet, consultez cet article.

Pourquoi générer et sélectionner des interactions de features ?

La génération et la sélection d'interactions de features sont cruciales dans le monde du machine learning. Pourquoi ? Parce que ces interactions capturent des signaux complexes souvent invisibles lorsque l'on examine les variables de manière isolée. Par exemple, la relation entre le revenu et le type de produit acheté peut varier considérablement selon le segment de clientèle. Si vous ne tenez pas compte de ces interactions, vous risquez de passer à côté de pistes précieuses qui pourraient améliorer vos prédictions.

Découvrez égalementQuels patterns analytiques un data scientist doit maîtriser?

Pour automatiser la génération de ces interactions, il est possible d'utiliser des opérations mathématiques simples. Pensez à créer des produits, des ratios, des sommes et des différences pour vos features numériques. Par exemple, si vous avez des features comme le prix et la quantité vendue, le produit de ces deux variables peut donner une indication précieuse sur le chiffre d'affaires. Pour les features catégorielles, combinez-les pour créer de nouvelles catégories qui peuvent révéler des insights cachés. Par exemple, la combinaison d'un type de produit et d'un canal de vente peut générer une variable qui capte le comportement d'achat spécifique à ce canal.

L'évaluation de l'utilité de ces interactions peut se faire via l'information mutuelle ou l'importance modèle, comme celle fournie par un modèle de type random forest. Ces méthodes vous permettent de quantifier dans quelle mesure chaque interaction contribue à la prédiction de votre variable cible. Une fois que vous avez généré un ensemble d'interactions, il est crucial de sélectionner les meilleures pour éviter l'explosion dimensionnelle. En effet, trop d'interactions peuvent rendre votre modèle confus et moins performant.

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

# Exemple de données
data = pd.DataFrame({
    'prix': [10, 20, 30],
    'quantité': [1, 2, 3],
    'type_produit': ['A', 'B', 'A']
})

# Génération d'interactions
data['chiffre_affaires'] = data['prix'] * data['quantité']

# Évaluation de l'utilité
interaction_importance = mutual_info_regression(data[['chiffre_affaires']], data['type_produit'])
print(interaction_importance)

Voici un tableau synthétique des types d'interactions et leurs bénéfices :

• Produits : Révèle des relations multiplicatives entre variables.
• Ratios : Capture des relations proportionnelles.
• Sommes : Montre des effets cumulatifs.
• Différences : Met en lumière des écarts significatifs.
• Combinaisons catégorielles : Dévoile des segments de marché spécifiques.

En automatisant ce processus, vous maximisez vos chances d'identifier des patterns complexes qui peuvent transformer vos modèles prédictifs. Pour approfondir le sujet, consultez cet article sur feature engineering.

Comment extraire automatiquement les features temporelles des dates ?

Découvrez égalementQuels sont les meilleurs cours SQL gratuits avec certificat ?

L'extraction automatique des features temporelles à partir de données datetime est un véritable atout pour améliorer la performance de vos modèles de machine learning. Pourquoi ? Parce que les données temporelles contiennent des informations cruciales : cycles mensuels, saisons, week-ends, jours fériés, etc. Ces éléments peuvent transformer des données brutes en insights précieux.

Voici quelques extractions clés que vous devriez considérer :

• Composantes de date : Extraire des éléments comme l'année, le mois, le jour et l'heure permet de décomposer les données temporelles en segments exploitables.
• Indicateurs booléens : Créer des flags pour les week-ends et les jours fériés peut aider votre modèle à identifier des comportements spécifiques liés à ces périodes.
• Encodages cycliques : Utiliser des transformations sinus et cosinus pour les mois et les heures garantit que les valeurs de fin et de début (comme décembre et janvier) sont proches dans l'espace des features, préservant ainsi la continuité.
• Calculs de durées : Mesurer le temps entre différentes dates (par exemple, entre une commande et une expédition) peut révéler des patterns d'efficacité ou de retard.

Un autre aspect à ne pas négliger est la gestion de plusieurs colonnes datetime. Si votre dataset contient plusieurs timestamps, le script doit être capable de traiter ces colonnes et de calculer les différences entre elles, ce qui est essentiel pour des analyses temporelles approfondies.

Pour détecter les jours fériés, vous pouvez intégrer des bibliothèques comme pandas qui facilitent cette tâche grâce à des listes prédéfinies.

Découvrez égalementComment la data analytics révolutionne-t-elle la sécurité en entrepôt ?

Voici un exemple de code Python avec pandas et numpy pour extraire ces features :

import pandas as pd
import numpy as np

# Exemple de DataFrame avec une colonne datetime
data = {'date': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-03'])}
df = pd.DataFrame(data)

# Extraction des composantes
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['hour'] = df['date'].dt.hour

# Indicateurs booléens
df['is_weekend'] = df['date'].dt.dayofweek >= 5

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

# Calcul de la durée entre dates
df['days_since'] = (pd.to_datetime('2023-01-10') - df['date']).dt.days

print(df)

Ce code produit plusieurs nouvelles colonnes qui enrichissent votre dataset avec des informations temporelles significatives. Voici un tableau récapitulatif des features datetime générées et leur intérêt :

Comment sélectionner automatiquement les features les plus pertinentes ?

La sélection automatique des features est une étape cruciale dans le processus de feature engineering. Pourquoi ? Parce qu'elle permet d'éliminer le bruit et la redondance, tout en évitant les problèmes d'overfitting et de complexité inutile. En d'autres termes, elle vous aide à conserver uniquement les informations pertinentes pour votre modèle, ce qui peut considérablement améliorer ses performances.

Alors, comment ça fonctionne ? La pipeline de sélection de features est généralement multi-étapes :

• Filtrage par variance : Cette étape élimine les features qui ont une variance proche de zéro, car elles n'apportent aucune information utile.
• Suppression des corrélations élevées : Ici, on repère les paires de features fortement corrélées et on conserve celle qui est la plus corrélée avec la variable cible.
• Tests statistiques : Des méthodes comme l'ANOVA, le chi-square et la mutual information permettent d'évaluer la relation entre les features et la cible.
• Importance modèle : Utiliser des modèles tels que les forêts aléatoires (random forest) ou la régularisation L1 pour mesurer l'importance des features.
• Élimination récursive : Cette technique consiste à entraîner un modèle, à évaluer l'importance des features et à supprimer les moins pertinentes, en répétant le processus jusqu'à obtenir le meilleur sous-ensemble.

À l'issue de ces étapes, les scores d'importance des différentes méthodes sont combinés pour obtenir un classement robuste des features. Cela permet de déterminer le nombre optimal de features à conserver, en garantissant que chaque feature ajoutée apporte une valeur ajoutée au modèle.

Voici un exemple de code Python qui illustre ces méthodes :

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel

# Chargement des données
data = load_iris()
X, y = data.data, data.target

# Modèle de forêt aléatoire
model = RandomForestClassifier()
model.fit(X, y)

# Sélection des features
selector = SelectFromModel(model, prefit=True)
X_selected = selector.transform(X)

print("Features sélectionnées :", selector.get_support())

Ce code charge un jeu de données, entraîne un modèle de forêt aléatoire et utilise la méthode de sélection de features pour ne garder que les plus pertinentes. Pour plus d'informations sur le rôle du feature engineering dans le machine learning, vous pouvez consulter cet article ici.

Pour résumer tout ça, voici un tableau synthétique des techniques de sélection et leur complémentarité :

Prêt à automatiser votre feature engineering et gagner en performance ?

L'automatisation du feature engineering avec ces cinq scripts Python vous libère du travail répétitif tout en maximisant la qualité de vos features. En encodant intelligemment vos catégories, transformant vos données numériques, générant des interactions pertinentes, extrayant les richesses temporelles et sélectionnant rigoureusement vos variables, vous boostez vos modèles de manière fiable et rapide. Vous gagnez du temps, évitez les erreurs classiques et augmentez vos chances de succès en machine learning. Alors, pourquoi continuer à bricoler quand la meilleure pratique est à portée de main ?

FAQ

A propos de l'auteur

Consultant et formateur en Analytics, Data et IA, je m’appelle Franck Scandolera. Fort de nombreuses années à déployer des solutions data-driven et automatiser les workflows IA, je partage mon expertise pour rendre le feature engineering accessible, pragmatique et performant. Basé à Brive-la-Gaillarde, j’accompagne entreprises et équipes en France, Suisse et Belgique à exploiter pleinement la puissance des données et de l'automatisation intelligente.

Franck Scandolera

⭐ Analytics engineer, Data Analyst et Automatisation IA indépendant ⭐

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

Mon terrain de jeu :

• Data Analyst & Analytics engineering : tracking avancé (GTM server, e-commerce, CAPI, RGPD), entrepôt de données (BigQuery, Snowflake, PostgreSQL, ClickHouse), modèles (Airflow, dbt, Dataform), dashboards décisionnels (Looker, Power BI, Metabase, SQL, Python).
• Automatisation IA des taches Data, Marketing, RH, compta etc : conception de workflows intelligents robustes (n8n, 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.