Automatiser le feature engineering en Python est possible grâce à cinq scripts clés qui optimisent la création, transformation et sélection des features. Ces outils simplifient la préparation des données, améliorant la performance des modèles sans perte de temps inutile.
3 principaux points à retenir.
- Encodez intelligemment vos variables catégorielles selon leur cardinalité et lien avec la cible.
- Transformez vos variables numériques en testant automatiquement plusieurs méthodes adaptées.
- Automatisez la sélection des meilleures features avec un ensemble de méthodes robustes pour éviter l’overfitting.
Comment gérer automatiquement les variables catégorielles ?
L’encodage automatique des variables catégorielles est un véritable atout pour quiconque souhaite simplifier la gestion de ses données. En effet, choisir la bonne méthode d’encodage en fonction du type et de la cardinalité des données peut faire toute la différence dans la performance de votre modèle. Imaginez un script en Python qui s’occupe de tout ça pour vous, sans vous faire perdre de temps dans des considérations techniques.
Pour les variables à faible cardinalité, le one-hot encoding est généralement la solution la plus appropriée. Par exemple, si vous avez une colonne « couleur » avec des valeurs comme « rouge », « vert », et « bleu », le one-hot encoding va créer trois nouvelles colonnes, une pour chaque couleur, où les valeurs seront soit 0 soit 1 selon la présence de la couleur pour chaque enregistrement.
Pour les catégories à haute cardinalité, comme les noms de villes, le frequency encoding devient plus judicieux. Ici, chaque catégorie est remplacée par le nombre de fois qu’elle apparaît dans l’ensemble de données. Cela réduit la dimensionnalité tout en préservant l’information essentielle.
Enfin, pour les catégories qui présentent une corrélation significative avec la variable cible, le target encoding est une méthode efficace. Elle remplace chaque catégorie par la moyenne de la cible pour cette catégorie, mais attention, cela comporte des risques de fuite de données si mal géré.
En plus de cela, un bon script doit aussi gérer les catégories rares et inconnues. Les catégories qui apparaissent dans moins de 1% des données peuvent être regroupées sous une étiquette « autres » pour éviter de créer des colonnes inutiles. De plus, pour les données de test, il est crucial que les catégories non vues soient traitées de manière cohérente, souvent en les remplaçant par une valeur par défaut.
import pandas as pd
# Exemple de DataFrame
data = {'couleur': ['rouge', 'vert', 'bleu', 'rouge', 'jaune', 'vert']}
df = pd.DataFrame(data)
# One-hot encoding
df_one_hot = pd.get_dummies(df, columns=['couleur'], drop_first=True)
print(df_one_hot)
Voici un tableau récapitulatif des méthodes d’encodage :
| Méthode | Avantages | Limites |
|---|---|---|
| One-hot encoding | Simple à comprendre, évite l’ordinalité | Augmente la dimensionnalité |
| Frequency encoding | Réduit la dimensionnalité, préserve l’information | Peut perdre des distinctions entre catégories |
| Target encoding | Capte la relation avec la cible | Risque de fuite de données, nécessite une gestion prudente |
Pour plus d’informations sur les meilleures pratiques pour gérer les variables catégorielles, je vous recommande de consulter cet article ici.
Comment optimiser la transformation des variables numériques ?
Transformer les variables numériques, c’est le secret pour améliorer la normalité et la robustesse de vos modèles de machine learning. Pourquoi ? Parce que des données bien distribuées facilitent la convergence des algorithmes et réduisent les risques de surapprentissage. En d’autres termes, si vous voulez que votre modèle soit performant, il faut s’assurer que vos données sont prêtes à l’emploi !
Voici un script qui va vous faire gagner un temps fou. Il teste plusieurs transformations sur vos variables numériques : logarithmique, Box-Cox, Yeo-Johnson, standardisation, et robust scaling. Le but ? Trouver la transformation la plus adaptée en fonction des distributions de vos données et des valeurs extrêmes.
Le script commence par évaluer chaque variable numérique avec des tests statistiques comme Shapiro-Wilk, qui mesure la normalité, et analyse l’asymétrie (skewness). Si une variable est très asymétrique, le script priorise des transformations comme le log ou Box-Cox, qui sont idéales pour corriger les distributions biaisées. Pour les valeurs extrêmes, le robust scaling entre en jeu, car il est moins sensible aux outliers.
import pandas as pd
from sklearn.preprocessing import PowerTransformer
from scipy.stats import shapiro
data = pd.read_csv('votre_donnees.csv')
transformer = PowerTransformer(method='box-cox')
data_transformed = transformer.fit_transform(data[['votre_variable']])
stat, p_value = shapiro(data_transformed)
if p_value > 0.05:
print('La distribution est normale')
else:
print('La distribution n\'est pas normale')Ce code lit vos données, applique la transformation Box-Cox, et vérifie si la distribution est normale ou non. Simple et efficace, non ?
Pour vous aider à choisir la bonne transformation selon vos besoins, voici un tableau comparatif :
| Transformation | Utilisation |
|---|---|
| Logarithmique | Pour les données asymétriques positives |
| Box-Cox | Pour des données positives avec asymétrie |
| Yeo-Johnson | Pour des données avec des valeurs négatives |
| Standardisation | Pour des données avec une moyenne de 0 et une variance de 1 |
| Robust Scaling | Pour des données avec des outliers |
Pour aller plus loin dans l’automatisation du feature engineering, vous pouvez consulter des ressources supplémentaires comme ce blog.
Comment générer et sélectionner les interactions de features ?
Les interactions entre features, c’est le secret bien gardé pour dénicher des signaux souvent ignorés. Imaginez que vous ayez une base de données où les revenus des clients varient non seulement selon leur âge, mais aussi en fonction de la saison. Ces interactions peuvent révéler des insights cruciaux que des features individuelles ne peuvent pas mettre en lumière. C’est là qu’un script efficace entre en jeu.
Le script que nous allons explorer génère des interactions de manière systématique. Pour les features numériques, il crée des produits, des ratios, des sommes et des différences. Par exemple, si vous avez les features prix et quantité, le script peut générer une nouvelle feature revenu en multipliant ces deux valeurs. Pour les features catégorielles, il génère des combinaisons, comme produit_catégorie qui pourrait fusionner un produit avec sa catégorie.
Pour évaluer la pertinence de ces interactions, le script utilise des mesures telles que l’information mutuelle ou l’importance d’un modèle random forest. Ces métriques permettent de quantifier la contribution de chaque interaction à la prédiction du modèle. Par exemple, si une interaction entre âge et type d’abonnement montre une forte importance, vous savez qu’elle mérite d’être conservée dans votre modèle.
Voici un exemple de génération d’interactions sur un DataFrame :
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import mutual_info_classif
# Exemple de DataFrame
data = pd.DataFrame({
'age': [25, 32, 45, 23, 36],
'abonnement': ['basic', 'premium', 'basic', 'premium', 'premium'],
'revenu': [50000, 70000, 60000, 30000, 80000]
})
# Génération d'interactions
data['age_abonnement'] = data['age'] * data['abonnement'].map({'basic': 1, 'premium': 2})
# Évaluation de l'importance
X = data[['age', 'revenu', 'age_abonnement']]
y = [0, 1, 0, 1, 1] # Supposons que ce soit notre variable cible
model = RandomForestClassifier()
model.fit(X, y)
importances = model.feature_importances_
print(importances)
Ce script vous permet non seulement de générer des interactions, mais également d’identifier celles qui sont réellement significatives pour votre modèle. Voici un tableau récapitulatif :
| Type d’interaction | Critères d’évaluation | Précautions |
|---|---|---|
| Produits, Ratios, Sommes, Différences | Importance du modèle, Information mutuelle | Éviter la multicolinéarité |
| Combinations catégorielles | Importance du modèle, Information mutuelle | Surveillance des catégories rares |
Utiliser un script pour générer et sélectionner des interactions de features, c’est un moyen efficace d’enrichir votre jeu de données et d’améliorer vos prédictions. Pour aller plus loin dans l’automatisation du feature engineering, n’hésitez pas à consulter ce lien.
Comment extraire automatiquement les informations pertinentes des dates ?
L’extraction automatique des composantes temporelles enrichit vos modèles avec des patterns souvent négligés. En effet, les données temporelles peuvent receler des informations cruciales, comme des tendances saisonnières ou des comportements cycliques. Un script efficace peut extraire des éléments essentiels tels que l’année, le mois, le jour, l’heure, les jours de la semaine, des flags pour les week-ends, les saisons, et même des indicateurs pour les jours fériés. De plus, il est possible d’encoder les variables cycliques en utilisant des transformations sinus/cosinus, ce qui préserve la continuité des données. Cela est particulièrement utile lorsque vous traitez des données temporelles, car cela évite de créer des discontinuités dans votre modèle.
Un autre aspect essentiel est la gestion des différences entre plusieurs colonnes datetime. Par exemple, si vous avez une date de commande et une date d’expédition, le script doit pouvoir calculer la durée entre ces deux événements, ajoutant ainsi une dimension supplémentaire aux données.
Voici un exemple de code qui extrait des features depuis une colonne datetime :
import pandas as pd
import numpy as np
# Exemple de DataFrame avec une colonne datetime
data = {'date': ['2023-01-01 10:30:00', '2023-01-02 12:45:00', '2023-01-03 14:15:00']}
df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])
# Extraction des features
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['hour'] = df['date'].dt.hour
df['weekday'] = df['date'].dt.weekday
df['is_weekend'] = np.where(df['weekday'] >= 5, 1, 0)
df['season'] = ((df['month'] % 12 + 3) // 3) % 4
df['holiday'] = df['date'].dt.date.apply(lambda x: x in [pd.to_datetime('2023-01-01').date()]) # Exemple de jour férié
# Encodage cyclique
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
print(df)
Voici un tableau synthétique des features temporelles extraites et leurs utilités :
- year: Année de la date, utile pour détecter des tendances sur plusieurs années.
- month: Mois de la date, important pour les analyses saisonnières.
- day: Jour du mois, pertinent pour des événements spécifiques.
- hour: Heure, utile pour des comportements horaires.
- weekday: Indique le jour de la semaine, essentiel pour des analyses de fréquentation.
- is_weekend: Flag pour les week-ends, important pour les comportements d’achat.
- season: Saison, utile pour des produits saisonniers.
- holiday: Indicateur de jours fériés, pertinent pour des campagnes marketing.
- month_sin & month_cos: Encodage cyclique, préserve la continuité des données temporelles.
Pour aller plus loin, vous pouvez consulter cette vidéo ici.
Comment automatiser la sélection des meilleures features ?
La sélection automatique des features est un incontournable pour éviter l’overfitting et optimiser la performance de vos modèles. En gros, vous voulez garder ce qui est essentiel et virer le superflu. Mais comment s’y prendre sans passer des heures à tester chaque variable ? La réponse réside dans un script qui combine plusieurs méthodes de sélection, rendant le processus à la fois efficace et fiable.
Ce script utilise une approche multi-étapes pour sélectionner les meilleures features. Voici les méthodes qu’il intègre :
- Élimination par variance : On commence par supprimer les features dont la variance est proche de zéro. Ces variables n’apportent aucune information utile.
- Filtrage de corrélation : Ensuite, on retire les features corrélées entre elles, en conservant celles qui ont la meilleure corrélation avec la cible.
- Tests statistiques : On applique des tests comme ANOVA, chi-deux et l’information mutuelle pour évaluer la pertinence des features.
- Importance par modèles d’arbres : Les arbres de décision, comme les forêts aléatoires, sont utilisés pour évaluer l’importance des features.
- Régularisation L1 : Cette technique aide à réduire le nombre de features en pénalisant les coefficients des moins significatives.
- Sélection récursive : On utilise la sélection récursive de features pour affiner le choix final, en gardant celles qui améliorent la performance du modèle.
Le script agrège les scores issus de ces différentes méthodes pour classer les features et choisir un sous-ensemble optimal. Voici un exemple de code pour illustrer cela :
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
# Charger les 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)
Comparons rapidement les méthodes de sélection :
| Méthode | Avantages | Inconvénients |
|---|---|---|
| Élimination par variance | Simple et rapide | Ne prend pas en compte la cible |
| Filtrage de corrélation | Élimine les redondances | Peut supprimer des features utiles |
| Tests statistiques | Statistiquement fondé | Peut être sensible aux outliers |
| Importance par modèles d’arbres | Prend en compte les interactions | Nécessite un modèle complexe |
| Régularisation L1 | Réduit le surapprentissage | Peut éliminer des features pertinentes |
| Sélection récursive | Optimise la performance | Peut être coûteux en calcul |
Avec ces outils, vous êtes armé pour automatiser la sélection des meilleures features et booster vos modèles. Pour aller plus loin, consultez cet article sur l’ingénierie des features.
Prêt à booster vos modèles grâce à l’automatisation du feature engineering ?
Ces cinq scripts Python révolutionnent votre approche du feature engineering en automatisant les tâches les plus fastidieuses et sensibles. De l’encodage des variables catégorielles à la sélection finale des features, ils garantissent une préparation de données plus rigoureuse, rapide et efficace. Vous gagnez ainsi du temps, évitez les erreurs humaines, et surtout améliorez significativement la performance de vos modèles. Intégrer ces outils dans votre pipeline, c’est passer de l’artisanat à la production industrielle du machine learning.
FAQ
Pourquoi automatiser le feature engineering en machine learning ?
Comment choisir la bonne méthode d’encodage pour les variables catégorielles ?
Quels tests statistiques sont utilisés pour choisir la transformation numérique ?
Comment éviter l’explosion du nombre de features avec les interactions ?
Quels sont les avantages d’une sélection de features multi-méthodes ?
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 l’intégration intelligente de l’IA dans leurs workflows métier. Responsable de l’agence webAnalyste et de l’organisme Formations Analytics, il maîtrise le développement d’applications IA et la mise en place de pipelines data automatisés. Basé à Brive‑la‑Gaillarde, il intervient en France, Suisse et Belgique pour transformer les données en leviers business concrets.
⭐ 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.