Le feature engineering automatisé en Python facilite la création et la sélection de caractéristiques pertinentes, boostant ainsi la performance des modèles. Découvrez 5 scripts Python clés qui simplifient encoding, transformation, interaction, extraction temporelle et sélection de features.
3 principaux points à retenir.
- Automatisation intelligente : encodez et transformez vos données selon leur nature sans code répétitif.
- Interaction et temporalité : générez des combinaisons et extrayez des patterns temporels pour enrichir vos modèles.
- Sélection optimisée : identifiez les features les plus impactantes via une approche multi-méthodes robuste.
Comment gérer l’encodage des variables catégorielles automatiquement ?
L’encodage des variables catégorielles peut rapidement devenir un casse-tête, surtout lorsque vous jonglez avec des ensembles de données volumineux. L’automatisation de ce processus est essentielle pour gagner du temps et éviter les erreurs. En analysant la cardinalité de chaque catégorie et sa corrélation avec la cible, l’algorithme peut choisir la méthode d’encodage la plus appropriée. Voici un aperçu des principales méthodes :
- One-hot encoding : Idéal pour les variables à faible cardinalité, il crée une colonne pour chaque catégorie. Cependant, il peut causer des problèmes de dimensionnalité avec des catégories à forte cardinalité.
- Label encoding : Efficace en mémoire, il attribue un numéro à chaque catégorie. Attention, cela implique une notion d’ordinalité qui peut être trompeuse.
- Target encoding : Cette méthode utilise la corrélation avec la cible pour encoder les catégories. Bien qu’efficace, elle présente un risque de fuite de données si mal gérée.
- Fréquence encoding : Utile pour les catégories à forte cardinalité, elle remplace chaque catégorie par sa fréquence d’apparition. Cela peut réduire la dimensionnalité tout en conservant des informations pertinentes.
Un autre aspect crucial est la gestion des 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 diluer les informations. Pour les catégories inconnues, il est vital de maintenir la cohérence entre les jeux de données d’entraînement, de validation et de test. Cela garantit que votre modèle reste robuste face à des données inattendues.
Voici un exemple de code Python simplifié qui illustre un encodage intelligent avec gestion des valeurs rares et inconnues :
import pandas as pd
def smart_encoder(df, target_col):
for col in df.select_dtypes(include=['object']).columns:
if df[col].nunique() 50:
freq_encoding = df[col].value_counts() / len(df)
df[col] = df[col].map(freq_encoding).fillna(0)
else:
target_mean = df.groupby(col)[target_col].mean()
df[col] = df[col].map(target_mean).fillna(0)
return df
# Exemple d'utilisation
data = pd.DataFrame({'category': ['A', 'B', 'A', 'C', 'D', 'D', 'C', 'E'], 'target': [1, 0, 1, 0, 1, 1, 0, 0]})
encoded_data = smart_encoder(data, 'target')
print(encoded_data)
En résumé, un bon encodage des variables catégorielles est crucial pour la performance de vos modèles. Chaque méthode a ses avantages et ses inconvénients, et le choix doit être fait en fonction des caractéristiques de vos données. Pour approfondir le sujet de l’ingénierie des caractéristiques, vous pouvez consulter cet article ici.
Quelles transformations appliquer aux variables numériques pour améliorer les modèles ?
Les transformations appliquées aux variables numériques sont indispensables pour améliorer la performance de vos modèles. Pourquoi ? Parce qu’elles corrigent des distributions biaisées, gèrent les outliers et harmonisent les échelles des données. En gros, elles préparent vos données pour qu’elles soient prêtes à être absorbées par des algorithmes d’apprentissage automatique.
Parmi les transformations les plus courantes, on trouve :
- Logarithmique : Utile pour réduire l’impact des valeurs extrêmes, elle transforme les distributions asymétriques en distributions plus normales.
- Box-Cox : Transforme les données pour qu’elles suivent une distribution normale, mais nécessite des valeurs positives.
- Racine carrée et racine cubique : Ces transformations sont efficaces pour réduire la skewness et sont souvent utilisées pour les données de comptage.
- Standardisation : Met à l’échelle les données pour qu’elles aient une moyenne de 0 et un écart-type de 1. Idéale lorsque les données suivent une distribution normale.
- Normalisation : Transforme les données pour qu’elles se situent entre 0 et 1, utile pour les algorithmes basés sur la distance.
- Robust Scaling : Utilise les quantiles pour réduire l’influence des outliers, ce qui est particulièrement utile dans des ensembles de données bruyants.
- Yeo-Johnson : Semblable à Box-Cox, mais elle peut gérer les valeurs négatives et les zéros.
Pour savoir quelle transformation appliquer, un script peut évaluer la normalité d’une distribution et la skewness de chaque variable. Par exemple, si vous avez des données très asymétriques, le script priorisera la transformation logarithmique ou Box-Cox.
import pandas as pd
from scipy import stats
# Exemple de données
data = pd.Series([10, 12, 13, 14, 15, 100])
# Appliquer plusieurs transformations
log_transformed = data.apply(lambda x: np.log(x) if x > 0 else 0)
boxcox_transformed, _ = stats.boxcox(data[data > 0])
# Évaluer la normalité
log_normality = stats.shapiro(log_transformed)
boxcox_normality = stats.shapiro(boxcox_transformed)
print(f'Log Normality: {log_normality}')
print(f'Box-Cox Normality: {boxcox_normality}')
En somme, le choix de la transformation dépend de la nature de vos données. Un tableau comparatif peut vous aider à choisir la transformation la plus appropriée selon les caractéristiques de vos données. Pour une analyse plus approfondie, vous pouvez consulter ce lien.
Comment générer et sélectionner les interactions de features pertinentes ?
Dans le monde du machine learning, les interactions entre features sont souvent la clé pour déceler des signaux que les features individuelles ne peuvent pas révéler. Par exemple, le comportement d’un client peut varier considérablement en fonction de la combinaison de son âge et de son statut d’abonnement. Ignorer ces interactions, c’est passer à côté d’informations cruciales.
La génération systématique d’interactions de features est donc essentielle. Pour les features numériques, on peut créer des interactions à travers des opérations mathématiques simples comme :
- Produits (x * y)
- Ratios (x / y)
- Sommes (x + y)
- Différences (x – y)
Pour les features catégorielles, les combinaisons de catégories peuvent également révéler des insights intéressants. Par exemple, combiner « type de produit » et « source de trafic » peut créer des groupes significatifs.
Mais comment savoir quelles interactions sont réellement utiles ? C’est là que la mutual information et l’importance via des modèles comme les forêts aléatoires entrent en jeu. Ces méthodes permettent d’évaluer la pertinence de chaque interaction tout en évitant l’explosion dimensionnelle que pourrait engendrer un trop grand nombre d’interactions. En filtrant les interactions selon leur score d’importance, vous vous concentrez uniquement sur celles qui apportent une réelle valeur ajoutée à votre modèle.
Voici un exemple de code Python pour générer des interactions et filtrer par score d’importance :
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import mutual_info_classif
from itertools import combinations
# Supposez que df soit votre DataFrame contenant les features
def generate_interactions(df):
numeric_features = df.select_dtypes(include=['float64', 'int']).columns
interactions = pd.DataFrame()
# Génération d'interactions numériques
for combo in combinations(numeric_features, 2):
interactions[f'{combo[0]}_times_{combo[1]}'] = df[combo[0]] * df[combo[1]]
interactions[f'{combo[0]}_divided_by_{combo[1]}'] = df[combo[0]] / df[combo[1]]
return interactions
# Filtrage par importance
def filter_important_interactions(X, y):
model = RandomForestClassifier()
model.fit(X, y)
importances = model.feature_importances_
return X.loc[:, importances > 0.01] # Gardez les features avec importance > 0.01
df_interactions = generate_interactions(df)
important_interactions = filter_important_interactions(df_interactions, df['target'])
Ce code illustre comment générer des interactions entre features et filtrer celles qui sont réellement pertinentes pour votre modèle. N’oubliez pas que chaque interaction que vous créez doit être justifiée par une hypothèse solide ou une observation empirique. Pour approfondir le sujet du feature engineering, vous pouvez consulter cet article ici.
En résumé, générer et sélectionner efficacement les interactions de features est un processus qui demande rigueur et méthode. En combinant des approches statistiques et des techniques de machine learning, vous pouvez optimiser vos modèles et tirer parti de chaque signal caché dans vos données.
Pourquoi et comment extraire automatiquement les features temporelles des dates ?
Les dates sont plus que de simples repères temporels dans vos données ; elles renferment une multitude d’informations précieuses qui peuvent booster la performance de vos modèles. L’extraction automatique de ces features temporelles permet de déceler des schémas cachés et des tendances qui autrement passeraient inaperçus. Voici quelques éléments clés à considérer lors de cette extraction.
- Composants de date : Chaque date peut être décomposée en éléments essentiels tels que l’année, le mois, le jour et l’heure. Ces composants sont cruciaux pour comprendre les comportements saisonniers ou hebdomadaires.
- Indicateurs : Créer des indicateurs comme le weekend, les jours fériés ou les saisons peut enrichir vos données. Par exemple, savoir si une date tombe un weekend pourrait influencer les comportements d’achat.
- Transformations cycliques : Les transformations sinusoïdales et cosinus permettent de capturer les périodicités. En appliquant ces techniques, vous pouvez vous assurer que décembre et janvier sont considérés comme proches dans l’espace des features.
- Gestion des dates multiples : Quand vous avez plusieurs colonnes de dates, comme une date de commande et une date d’expédition, il est crucial de calculer les différences entre elles pour extraire des insights tels que le temps de traitement.
Voici un exemple de code Python qui illustre comment extraire ces features temporelles, y compris le codage cyclique :
import pandas as pd
import numpy as np
# Exemple de données
data = {'date': pd.to_datetime(['2023-01-01', '2023-07-15', '2023-12-25'])}
df = pd.DataFrame(data)
# Extraction des composants
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
df['is_weekend'] = df['date'].dt.dayofweek >= 5
df['is_holiday'] = df['date'].isin(pd.to_datetime(['2023-01-01', '2023-12-25']))
# Transformations cycliques
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
# Affichage des résultats
print(df)
Ce code génère plusieurs features temporelles qui peuvent être cruciales pour vos analyses. Voici un tableau récapitulatif des features extraites et de leur utilité :
| Feature | Utilité |
|---|---|
| year | Permet d’analyser les tendances annuelles. |
| month | Identifie les variations saisonnières. |
| day | Peut révéler des comportements quotidiens. |
| is_weekend | Indique si une date tombe un weekend, influençant les comportements. |
| month_sin / month_cos | Capture les effets cycliques des mois dans les données. |
En maîtrisant l’extraction automatique des features temporelles, vous maximisez vos chances d’optimiser vos modèles de manière significative. Pour aller plus loin dans l’analyse de données avec Python, vous pouvez consulter cet article.
Comment sélectionner automatiquement les meilleures features pour un modèle ?
La sélection automatique des meilleures features pour un modèle est l’une des étapes cruciales en machine learning, et elle peut grandement influencer la performance de votre modèle. En combinant plusieurs méthodes de sélection, vous pouvez extraire les caractéristiques les plus pertinentes sans vous perdre dans un dédale de données. Voici comment cela fonctionne.
Tout d’abord, la sélection commence par le filtrage par variance, qui élimine les features constantes ou presque constantes, car elles n’apportent aucune information utile. Ensuite, on utilise le filtrage par corrélation pour retirer les features redondantes, en conservant celle qui a la corrélation la plus forte avec la variable cible.
Les tests statistiques tels que l’ANOVA, le chi carré, et la mutual information sont ensuite appliqués pour évaluer l’importance des features. Ces tests permettent de déterminer quelles features ont un impact significatif sur la variable cible, en se basant sur des critères quantitatifs.
Ensuite, la régularisation L1 (Lasso) et l’importance des arbres (comme celle des forêts aléatoires) sont utilisées pour évaluer la contribution de chaque feature dans un modèle. La régularisation L1, par exemple, peut forcer certaines coefficients à zéro, ce qui aide à réduire la complexité du modèle.
Enfin, l’élimination récursive de features (RFE) permet d’affiner encore plus la sélection en évaluant les performances du modèle à chaque étape, en retirant les features les moins importantes.
Un exemple de pipeline Python intégrant ces étapes pourrait ressembler à ceci :
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
# Charger les données
X, y = load_iris(return_X_y=True)
# Modèle de base
model = RandomForestClassifier()
# Sélection de features avec RFE
selector = RFE(estimator=LogisticRegression(), n_features_to_select=2)
X_rfe = selector.fit_transform(X, y)
# Sélection par importance d'arbre
model.fit(X_rfe, y)
selector_model = SelectFromModel(model, prefit=True)
X_selected = selector_model.transform(X_rfe)
print(X_selected)
Ce pipeline illustre comment combiner plusieurs méthodes pour obtenir une sélection robuste et efficace. La clé réside dans l’agrégation des scores de chaque méthode pour établir un classement final des features.
| Méthode | Avantages | Limites |
|---|---|---|
| Filtrage par variance | Simple à appliquer, rapide | Ne tient pas compte de la relation avec la cible |
| Filtrage par corrélation | Élimine les redondances | Peut manquer des interactions non linéaires |
| Tests statistiques | Évaluation objective | Peut être sensible aux outliers |
| Régularisation L1 | Réduit la complexité du modèle | Peut éliminer des features importantes |
| Élimination récursive | Affinage progressif | Peut être coûteux en temps de calcul |
Prêt à booster vos modèles grâce au feature engineering automatisé ?
Ces cinq scripts Python transforment le feature engineering d’un travail laborieux en un processus fluide, systématique et fiable. Vous encodez intelligemment, transformez vos données numériques, générez des interactions puissantes, exploitez pleinement les données temporelles et sélectionnez les features les plus pertinentes. Résultat : des modèles plus performants, sans perte de temps ni erreurs manuelles. Intégrer ces outils dans votre pipeline, c’est gagner en efficacité et en qualité, un vrai levier pour vos projets data.
FAQ
Pourquoi automatiser le feature engineering ?
Comment gérer les catégories rares ou inconnues lors de l’encodage ?
Quelles transformations numériques sont adaptées aux données avec valeurs négatives ?
Comment éviter l’explosion du nombre de features avec les interactions ?
Quelle méthode est la plus fiable pour sélectionner les features ?
A propos de l’auteur
Franck Scandolera, consultant et formateur expert en Analytics, Data, Automatisation et IA, accompagne les entreprises dans la mise en œuvre de solutions avancées d’intégration et de développement IA. Fort de plusieurs années d’expérience dans le développement d’applications IA (OpenAI API, Hugging Face, LangChain) et l’automatisation des workflows métier (n8n), il partage son savoir-faire pour rendre le feature engineering accessible, pragmatique et efficace.
⭐ 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.