Automatiser le feature engineering en Python est possible grâce à cinq scripts clés qui optimisent encoding, transformations, interactions, extraction temporelle et sélection de variables. Ces outils améliorent la performance de vos modèles sans y passer des heures.
3 principaux points à retenir.
- Automatisation ciblée : scripts adaptés à chaque type de données pour éviter les erreurs manuelles.
- Optimisation des performances : transformations et sélections basées sur des critères statistiques et modèles.
- Gain de temps : pipeline complet pour générer et sélectionner des features pertinentes rapidement.
Pourquoi et comment encoder correctement les variables catégorielles ?
L’encodage des variables catégorielles est un enjeu crucial en machine learning. Pourquoi ? Parce qu’une mauvaise gestion de ces données peut mener à des modèles biaisés ou inefficaces. Imaginez que vous ayez une variable catégorielle avec des catégories rares ou à haute cardinalité. Si vous la traitez mal, vous risquez de perdre des informations précieuses ou d’introduire du bruit dans votre modèle.
Il existe plusieurs méthodes d’encodage, chacune ayant ses avantages et ses inconvénients :
- One-hot encoding : Idéal pour les variables à faible cardinalité, il crée une colonne pour chaque catégorie. Cependant, avec de nombreuses catégories, cela peut entraîner une explosion dimensionnelle.
- Label encoding : Cette méthode est économique en mémoire, mais elle suppose une ordonnancement entre les catégories, ce qui peut être trompeur.
- Target encoding : Elle permet d’utiliser la corrélation entre la catégorie et la variable cible, mais attention à la fuite de données !
- Frequency encoding : Elle remplace les catégories par leur fréquence d’apparition, ce qui peut être efficace pour des catégories à haute cardinalité.
Pour automatiser ce choix d’encodage, un script Python peut être d’une grande aide. Ce script analyse chaque variable catégorielle en fonction de sa cardinalité et de sa corrélation avec la cible. Par exemple :
def smart_encoder(data, target):
for column in data.select_dtypes(include=['object']).columns:
cardinality = data[column].nunique()
if cardinality < 10:
data = pd.get_dummies(data, columns=[column], drop_first=True)
elif cardinality > 50:
data[column] = data[column].map(data[column].value_counts())
else:
# Implémentation du target encoding
mean_target = data.groupby(column)[target].mean()
data[column] = data[column].map(mean_target)
return data
Ce script gère également les catégories rares en les regroupant dans une catégorie « autre » et traite les catégories inconnues dans les données de test. Vous pouvez le retrouver ici : encoder les variables catégorielles.
Voici un tableau récapitulatif des différentes méthodes d’encodage :
| Méthode | Avantages | Inconvénients |
|---|---|---|
| One-hot encoding | Simple, intuitive | Explosion dimensionnelle |
| Label encoding | Économique en mémoire | Implicite ordonnancement |
| Target encoding | Utilise l’information cible | Risque de fuite de données |
| Frequency encoding | Pratique pour haute cardinalité | Moins intuitif |
Comment transformer efficacement les variables numériques ?
Les variables numériques brutes, souvent issues de capteurs ou de systèmes de gestion, nécessitent des transformations pour être exploitables dans un modèle de machine learning. Pourquoi ? Parce que ces données peuvent présenter des asymétries, des outliers, et des échelles différentes qui perturbent les algorithmes. L’objectif est d’harmoniser ces variables afin d’améliorer la performance des modèles.
Le script que nous allons explorer automatise ce processus en testant plusieurs transformations, dont :
- Transformation logarithmique : utile pour réduire l’impact des outliers et rendre la distribution plus normale.
- Box-Cox : une transformation puissante qui nécessite des valeurs positives, mais qui peut transformer des données très asymétriques.
- Racine carrée : souvent utilisée pour atténuer des distributions asymétriques.
- Standardisation : centre les données autour de la moyenne avec un écart type de 1, idéal pour les algorithmes sensibles à l’échelle.
- Robust scaling : utile pour gérer les outliers en utilisant les percentiles.
- Yeo-Johnson : similaire à Box-Cox, mais il peut gérer les valeurs négatives et zéro.
Pour évaluer l’efficacité de chaque transformation, le script utilise des tests de normalité tels que Shapiro-Wilk et Anderson-Darling, ainsi que des mesures de skewness. Par exemple, si une variable présente une skewness supérieure à 1, le script privilégie la transformation logarithmique ou Box-Cox pour corriger cette asymétrie.
Voici un exemple de code qui montre comment appliquer ces transformations automatiquement tout en gérant les valeurs négatives et zéro :
import pandas as pd
import numpy as np
from scipy import stats
def transform_numeric_features(df):
for column in df.select_dtypes(include=[np.number]).columns:
skewness = df[column].skew()
if skewness > 1:
df[column] = np.log1p(df[column]) # Log transformation
elif skewness < -1:
df[column] = stats.boxcox(df[column] + 1)[0] # Box-Cox transformation
else:
df[column] = (df[column] - df[column].mean()) / df[column].std() # Standardization
return df
# Utilisation
data = pd.DataFrame({'A': [1, 2, 3, 4, 100], 'B': [1, 2, 3, 4, 5]})
transformed_data = transform_numeric_features(data)
print(transformed_data)
Pour résumer, voici un tableau synthétique des transformations et leurs cas d’application :
| Transformation | Cas d'application |
|---|---|
| Log | Données asymétriques avec outliers |
| Box-Cox | Données positives très asymétriques |
| Racine carrée | Données légèrement asymétriques |
| Standardisation | Algorithmes sensibles à l'échelle |
| Robust scaling | Données avec outliers |
| Yeo-Johnson | Données avec valeurs négatives et zéro |
Ces transformations automatisées vous feront gagner un temps précieux et amélioreront la qualité de vos modèles. Pour une démonstration plus visuelle, vous pouvez consulter cette vidéo ici.
Comment générer et sélectionner automatiquement les interactions de features ?
Les interactions entre variables sont souvent la clé pour déceler des signaux cachés dans vos données. Imaginez que vous ayez des données sur des clients avec des caractéristiques individuelles, mais que ces caractéristiques, prises isolément, ne révèlent pas grand-chose sur leurs comportements d'achat. C'est là que les interactions entrent en jeu. Mais générer toutes les combinaisons possibles est non seulement coûteux en temps, mais cela peut également entraîner un surajout de variables qui nuisent à votre modèle. C'est pourquoi un script bien conçu pour créer des interactions est essentiel.
Ce script s'attaque à la problématique en générant des interactions mathématiques (produits, ratios, sommes, différences) ainsi que des combinaisons catégorielles. Ensuite, il évalue l'utilité de chaque interaction à l'aide de métriques telles que la mutual information ou les scores d'importance de modèle. En conséquence, vous obtenez uniquement les interactions les plus significatives, ce qui permet de garder votre modèle léger et performant.
Il est également crucial de gérer les exceptions potentielles qui peuvent survenir lors de la génération de ces interactions. Par exemple, la division par zéro ou les valeurs infinies peuvent rapidement devenir des pièges. Le script doit être capable de traiter ces cas en les excluant ou en les remplaçant par des valeurs par défaut, garantissant ainsi la robustesse de votre pipeline d'ingénierie des features.
Voici un exemple de code qui illustre comment générer et sélectionner des interactions de features :
import pandas as pd
from sklearn.feature_selection import mutual_info_regression
# Exemple de données
data = pd.DataFrame({
'feature1': [1, 2, 3, 4],
'feature2': [10, 20, 30, 40]
})
# Génération des interactions
data['interaction'] = data['feature1'] * data['feature2']
# Évaluation de l'importance
X = data[['feature1', 'feature2', 'interaction']]
y = [1, 2, 3, 4] # Variable cible
mi = mutual_info_regression(X, y)
print(mi)
Dans cet exemple, une interaction simple entre feature1 et feature2 est créée, puis son importance est évaluée. Ce processus peut être étendu pour inclure d'autres types d'interactions et des techniques de sélection plus sophistiquées.
Voici un tableau récapitulatif des types d'interactions et des critères de sélection :
| Type d'interaction | Critères de sélection |
|---|---|
| Produits | Mutual Information, Importance modèle |
| Ratios | Statistiques, Tests d'hypothèse |
| Sommes/Différences | Analyse de variance, Importance des arbres |
| Combinations catégorielles | Tests Chi-2, Coefficients de corrélation |
En résumé, automatiser la génération et la sélection des interactions de features vous permet d'explorer des dimensions cachées de vos données sans vous perdre dans un océan de combinaisons inutiles.
Comment extraire automatiquement les features temporelles pertinentes ?
Les données temporelles sont souvent sous-exploitées, alors qu'elles recèlent des informations essentielles sur la saisonnalité, les cycles et les événements spéciaux. Pour tirer parti de ces richesses, il est crucial d'extraire automatiquement des caractéristiques pertinentes à partir des colonnes datetime. C'est là qu'intervient notre script d'extraction de features temporelles.
Ce script se charge de décomposer les dates en plusieurs composantes clés : année, mois, jour et heure. En plus de cela, il crée des indicateurs booléens tels que les weekends et les jours fériés, et applique des transformations cycliques à l'aide de fonctions sinus et cosinus. Pourquoi est-ce important ? Parce que cela permet de gérer les discontinuités dans les données. Par exemple, sans ces transformations, décembre et janvier seraient considérés comme éloignés l'un de l'autre, alors qu'ils sont en réalité consécutifs dans un cycle annuel.
Voici un exemple de code pour extraire des caractéristiques temporelles d'une colonne datetime :
import pandas as pd
import numpy as np
# Création d'un DataFrame exemple
data = {'date': pd.date_range(start='2022-01-01', periods=12, freq='M')}
df = pd.DataFrame(data)
# Fonction d'extraction de features temporelles
def extract_datetime_features(df, date_col):
df[date_col] = pd.to_datetime(df[date_col])
df['year'] = df[date_col].dt.year
df['month'] = df[date_col].dt.month
df['day'] = df[date_col].dt.day
df['hour'] = df[date_col].dt.hour
df['is_weekend'] = df[date_col].dt.dayofweek >= 5
df['is_holiday'] = df[date_col].dt.date.isin(pd.to_datetime(['2022-01-01', '2022-12-25']).date)
df['month_sin'] = np.sin(2 * np.pi * df['month']/12)
df['month_cos'] = np.cos(2 * np.pi * df['month']/12)
extract_datetime_features(df, 'date')
print(df.head())Ce code extrait non seulement les composantes de base de la date, mais il crée également des indicateurs qui peuvent être cruciaux pour des modèles de machine learning. Par exemple, les indicateurs de weekend peuvent aider à prédire les comportements d'achat, tandis que les transformations cycliques assurent que les mois de décembre et janvier sont correctement traités comme des points adjacents dans le temps.
Pour résumer, voici un tableau récapitulatif des features temporelles extraites et leur utilité :
| Feature | Utilité |
|---|---|
| year | Analyse des tendances annuelles |
| month | Identification de la saisonnalité |
| day | Comportements quotidiens |
| hour | Analyse de l'heure de la journée |
| is_weekend | Comportement différent le weekend |
| is_holiday | Impact des jours fériés sur les ventes |
| month_sin/cos | Gestion des discontinuités saisonnières |
En intégrant ces fonctionnalités, vous maximisez votre capacité à capturer les tendances temporelles dans vos modèles. Pour approfondir vos connaissances sur l'analyse de données avec Python, vous pouvez consulter cet article.
Comment sélectionner automatiquement les meilleures features pour votre modèle ?
La sélection de features est essentielle dans le monde du machine learning. Pourquoi ? Parce qu'une sélection appropriée permet d'éviter le surapprentissage et de réduire la complexité des modèles. En gros, vous voulez garder ce qui compte vraiment et jeter le reste. Mais comment faire cela de manière efficace ? C'est là qu'un pipeline de sélection de features multi-méthodes entre en jeu.
Le script que nous allons examiner utilise plusieurs techniques pour identifier les meilleures features. Voici un aperçu des étapes clés :
- Élimination des variables quasi-constantes : Cela consiste à retirer les features qui n'apportent aucune information. Les variables qui ne changent presque pas ne servent à rien.
- Suppression des corrélations fortes : Si deux features sont fortement corrélées, l'une d'elles peut être supprimée pour éviter la redondance.
- Tests statistiques : Des méthodes comme l'ANOVA, le chi-carré et la mutual information sont utilisées pour évaluer la pertinence des features par rapport à la cible.
- Importance via arbres : Les modèles basés sur des arbres, comme les forêts aléatoires, aident à mesurer l'importance des features.
- L1 régularisation : Cette technique pénalise les coefficients des features pour réduire le nombre de variables dans le modèle.
- Élimination récursive : Cela permet de déterminer le nombre optimal de features en éliminant progressivement celles qui sont les moins pertinentes.
Le script fusionne ensuite les scores obtenus à partir de ces différentes méthodes en un ranking global. Cela permet de voir clairement quelles features sont les plus prometteuses. En utilisant ce ranking, vous pouvez choisir un sous-ensemble optimal de features qui maximisera les performances de votre modèle tout en minimisant la complexité.
Voici un exemple simple de code pour illustrer l’usage de ce pipeline :
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier
# Supposons que X_train et y_train soient vos données d'entraînement
model = RandomForestClassifier()
model.fit(X_train, y_train)
# Sélection des features
selector = SelectFromModel(model, prefit=True)
X_selected = selector.transform(X_train)
Avec ce code, vous pouvez facilement sélectionner les features les plus pertinentes pour votre modèle. C'est simple et efficace.
Prêt à booster vos modèles grâce à une feature engineering automatisée et intelligente ?
Ces cinq scripts Python couvrent les étapes essentielles du feature engineering : encodage intelligent des catégories, transformation optimale des numériques, génération ciblée d’interactions, extraction complète des informations temporelles, et sélection rigoureuse des variables. Leur utilisation vous fait gagner un temps précieux tout en améliorant la qualité de vos features et la performance de vos modèles. Adopter ces outils, c’est s’assurer d’une approche systématique, reproductible et scientifiquement robuste pour vos projets de machine learning.
FAQ
Pourquoi automatiser le feature engineering en Python ?
Comment choisir la méthode d'encodage pour les variables catégorielles ?
Quelles transformations appliquer aux variables numériques ?
Comment détecter les interactions de features intéressantes ?
Pourquoi utiliser un pipeline de sélection de features multiple ?
A propos de l'auteur
Franck Scandolera, consultant et formateur expert en Analytics, Data, Automatisation et IA, accompagne depuis plus de 10 ans les entreprises dans la mise en œuvre d’outils intelligents et automatisés. Spécialisé dans le développement d’applications IA et l’intégration de workflows basés sur OpenAI API et LangChain, il partage des solutions concrètes pour optimiser vos projets data. Responsable de l’agence webAnalyste et de l’organisme Formations Analytics, il intervient en France, Suisse et Belgique pour transformer la donnée en levier business.
⭐ 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.