Automatiser le feature engineering avec Python optimise vos modèles en un temps record. Ces 5 scripts ciblent encoding, transformation, interactions, extraction temporelle et sélection automatique pour booster vos performances sans perdre de temps.
3 principaux points à retenir.
- Automatisation : gagnez en efficacité en déléguant les tâches manuelles de feature engineering.
- Qualité : améliorez la pertinence des features grâce à des transformations adaptées et des interactions ciblées.
- Sélection optimale : éliminez le superflu pour maximiser la performance et limiter l’overfitting.
Pourquoi automatiser l’encodage des variables catégorielles ?
L’encodage des variables catégorielles est un passage obligé dans le monde du machine learning, mais il peut rapidement devenir un casse-tête, surtout lorsque vous devez jongler avec des catégories nombreuses ou rares. Chaque méthode d’encodage a ses propres avantages et inconvénients, et le choix de la bonne méthode peut faire la différence entre un modèle performant et un modèle qui stagne. Alors, comment automatiser ce processus en choisissant la méthode d’encodage adaptée selon la cardinalité et la corrélation avec la cible ?
Voici les principales stratégies d’encodage que vous devez connaître :
- One-hot encoding : Idéal pour les variables à faible cardinalité, cette méthode crée des colonnes binaires pour chaque catégorie. Mais attention, avec des catégories nombreuses, vous risquez de vous retrouver avec un nombre de colonnes astronomique, ce qui peut nuire à la performance du modèle.
- Label encoding : Plus économe en mémoire, il attribue un nombre unique à chaque catégorie. Cependant, cette méthode implique une ordinality que certaines catégories n’ont pas, ce qui peut induire le modèle en erreur.
- Target encoding : Cette méthode utilise la corrélation entre la variable catégorielle et la cible pour créer des encodages. C’est puissant, mais attention à la fuite de données !
- Frequency encoding : Pour les variables à haute cardinalité, cette méthode remplace chaque catégorie par sa fréquence d’apparition. Cela conserve l’information tout en évitant la malédiction de la dimensionnalité.
Un aspect crucial est la gestion des catégories rares et des valeurs inconnues. Il est essentiel de regrouper les catégories rares dans une catégorie « autre » pour éviter que ces données ne polluent votre modèle. De plus, pour les valeurs non vues dans les données de test, vous devez définir une stratégie claire pour les traiter, par exemple en les remplaçant par la moyenne globale ou en les assignant à la catégorie « autre ».
Voici un exemple de code Python qui applique ces méthodes d’encodage automatiquement :
import pandas as pd
from category_encoders import TargetEncoder
def smart_encoder(df, target):
categorical_features = df.select_dtypes(include=['object', 'category']).columns
for feature in categorical_features:
cardinality = df[feature].nunique()
if cardinality 50:
df[feature] = df[feature].map(df[feature].value_counts())
else:
encoder = TargetEncoder(cols=[feature])
df[feature] = encoder.fit_transform(df[feature], df[target])
return df
df = pd.DataFrame({'category': ['A', 'B', 'A', 'C', 'B'], 'target': [1, 0, 1, 0, 1]})
df_encoded = smart_encoder(df, 'target')
print(df_encoded)
En automatisant l’encodage des variables catégorielles, vous réduisez non seulement le risque d’erreurs, mais vous améliorez aussi l’efficacité de votre workflow. Pour approfondir le sujet, n’hésitez pas à consulter cet article sur le feature engineering.
Comment transformer efficacement les variables numériques ?
Transformer efficacement les variables numériques est crucial pour améliorer la performance de vos modèles de machine learning. En effet, les données brutes peuvent souvent présenter des distributions skewed, des outliers ou des échelles différentes qui peuvent fausser les résultats. Voici un aperçu des transformations courantes que vous pouvez appliquer.
- Transformation logarithmique : Cette méthode est idéale pour réduire la skewness des distributions positives. Par exemple, si vous avez un revenu qui varie énormément, appliquer un log peut rendre la distribution plus normale.
- Transformation Box-Cox : C’est une généralisation de la transformation logarithmique qui peut être appliquée à des données positives. Elle est particulièrement utile lorsque vous devez stabiliser la variance.
- Racine carrée : Une autre option pour réduire la skewness, surtout pour les données qui ont une distribution fortement asymétrique.
- Standardisation : Cette méthode transforme vos données pour qu’elles aient une moyenne de 0 et un écart-type de 1. C’est essentiel lorsque les algorithmes de machine learning sont sensibles à l’échelle des données, comme les SVM ou les réseaux de neurones.
- Robust scaling : Utilisez cette méthode si vous avez des outliers dans vos données. Elle utilise la médiane et l’écart interquartile pour transformer les données, ce qui la rend moins sensible aux valeurs extrêmes.
- Power transforms : Des transformations comme Yeo-Johnson permettent de traiter à la fois les valeurs négatives et les zéros, offrant ainsi plus de flexibilité dans le préprocessing des données.
Pour évaluer la normalité des distributions, vous pouvez utiliser des tests statistiques tels que le test de Shapiro-Wilk ou le test d’Anderson-Darling. Ces tests vous aideront à déterminer si les transformations appliquées ont effectivement amélioré la normalité de vos variables. Par exemple, si un test de Shapiro-Wilk donne une p-value inférieure à 0.05, cela indique que la distribution n’est pas normale.
Voici un exemple de script Python qui automatise ces transformations et tests :
import pandas as pd
from scipy import stats
from sklearn.preprocessing import PowerTransformer
def transform_numerical_features(df):
for column in df.select_dtypes(include=['float64', 'int64']).columns:
# Test de normalité
stat, p = stats.shapiro(df[column])
if p En appliquant ces transformations, vous vous assurez que vos modèles de machine learning fonctionnent avec des données optimales et pertinentes. Pour plus d'informations sur le rôle du feature engineering dans le machine learning, consultez cet article ici.
Pourquoi générer des interactions de features et comment ?
Les interactions entre features sont souvent des mines d'or pour améliorer les performances de vos modèles. Quand on parle d'interactions, on fait référence à la combinaison de plusieurs variables qui, ensemble, peuvent révéler des patterns que les variables prises isolément ne peuvent pas. Par exemple, le revenu d'un client peut avoir un impact différent selon son âge ou son lieu de résidence. Tester toutes les combinaisons de features manuellement, c'est un peu comme chercher une aiguille dans une botte de foin : c'est long, fastidieux et, soyons honnêtes, peu efficace.
C'est là qu'intervient l'automatisation. En utilisant des scripts Python, vous pouvez générer automatiquement des interactions entre vos features sans vous perdre dans une mer de combinaisons. Cela inclut des opérations mathématiques comme les produits, les ratios, les sommes, les différences, ainsi que des combinaisons de variables catégorielles. Grâce à ces techniques, vous pouvez découvrir des signaux cachés qui peuvent considérablement augmenter la puissance prédictive de votre modèle.
Mais comment évaluer la pertinence de ces interactions ? Deux méthodes efficaces sont l'utilisation de scores d'importance basés sur l'information mutuelle et l'importance modèle. L'information mutuelle mesure la dépendance entre deux variables, tandis que l'importance modèle évalue la contribution de chaque feature à la performance du modèle. En ne conservant que les interactions qui dépassent un certain seuil d'importance, vous évitez d'alourdir votre modèle avec des features redondantes ou non pertinentes.
Voici un exemple de code Python qui génère des interactions et sélectionne automatiquement les plus pertinentes :
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import mutual_info_classif
from itertools import combinations
# Chargement de vos données
data = pd.read_csv('votre_fichier.csv')
X = data.drop('target', axis=1)
y = data['target']
# Génération d'interactions
def generate_interactions(X):
for col1, col2 in combinations(X.columns, 2):
X[f'{col1}_x_{col2}'] = X[col1] * X[col2]
X[f'{col1}_div_{col2}'] = X[col1] / (X[col2] + 1e-5) # éviter la division par zéro
return X
X_interactions = generate_interactions(X.copy())
# Sélection des features
model = RandomForestClassifier()
model.fit(X_interactions, y)
importances = model.feature_importances_
# Évaluation avec l'information mutuelle
mi = mutual_info_classif(X_interactions, y)
selected_features = X_interactions.columns[mi > 0.1] # Seuil d'importance
print("Features sélectionnées :", selected_features)
Avec ce script, vous pouvez générer des interactions et sélectionner celles qui apportent réellement de la valeur ajoutée. Pour aller plus loin dans le domaine du feature engineering, n'hésitez pas à consulter ce lien, qui propose des ressources supplémentaires sur le sujet.
Quels bénéfices tirer de l'extraction automatique des features temporelles ?
Les données temporelles recèlent souvent des informations précieuses, mais trop de professionnels les négligent. Pourquoi ? Parce qu’extraire des composants de date-heure à la main, c'est un vrai casse-tête. Pourtant, avec un peu d'automatisation, vous pouvez transformer ces données en or ! En extrayant automatiquement des éléments comme l'année, le mois, le jour, et l'heure, vous vous donnez les moyens d'analyser des tendances et des saisonnalités qui peuvent faire la différence.
Imaginez que vous travaillez sur des données de vente. Si vous extrayez le jour de la semaine ou si vous créez des indicateurs pour les week-ends et les jours fériés, vous pourrez mieux comprendre l'impact de ces périodes sur vos ventes. Les transformations cycliques, comme les encodages sinusoïdaux pour le mois ou l'heure, vous permettent de capter des patterns saisonniers. Par exemple, au lieu de traiter janvier et décembre comme deux mois distincts, vous pouvez les rapprocher dans votre modèle, ce qui améliore la qualité de vos prédictions.
En plus, calculer les différences temporelles entre deux dates vous aide à mesurer des durées, comme le temps écoulé entre une commande et sa livraison. Cela peut révéler des inefficacités dans votre chaîne logistique ou des opportunités d'amélioration.
Voici un exemple de script Python qui réalise ces extractions de manière systématique :
import pandas as pd
import numpy as np
def extract_datetime_features(df, datetime_col):
df[datetime_col] = pd.to_datetime(df[datetime_col])
df['year'] = df[datetime_col].dt.year
df['month'] = df[datetime_col].dt.month
df['day'] = df[datetime_col].dt.day
df['hour'] = df[datetime_col].dt.hour
df['weekday'] = df[datetime_col].dt.weekday
df['is_weekend'] = np.where(df['weekday'] >= 5, 1, 0)
df['quarter'] = df[datetime_col].dt.quarter
# Encodages sinusoïdaux
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
# Différences temporelles
df['time_since_epoch'] = (df[datetime_col] - pd.Timestamp("1970-01-01")) // pd.Timedelta('1s')
return df
# Exemple d'utilisation
data = {'date': ['2023-01-01', '2023-06-15', '2023-12-10']}
df = pd.DataFrame(data)
df = extract_datetime_features(df, 'date')
print(df)Ce script automatise l'extraction des composantes essentielles de vos données temporelles, rendant votre analyse beaucoup plus efficace. Si vous souhaitez approfondir ce sujet, je vous recommande de consulter cet article qui couvre des techniques d'extraction de features pour le machine learning.
Comment sélectionner automatiquement les meilleures features ?
Une fois que vous avez généré vos features, il est crucial de comprendre que toutes ne sont pas pertinentes. En fait, certaines peuvent même nuire à la performance de votre modèle en introduisant du bruit, de la redondance ou en provoquant un surapprentissage. C'est là qu'intervient la sélection automatique des features, un processus indispensable pour optimiser vos modèles de machine learning.
La sélection automatique repose sur plusieurs méthodes combinées qui permettent d'évaluer l'importance des features et de conserver uniquement celles qui apportent une réelle valeur ajoutée. Voici les principales techniques que vous devez connaître :
- Filtrage par variance : Cette méthode élimine les features qui n'ont que peu ou pas de variance. Si une feature ne varie pas beaucoup, elle n'apporte pas d'information significative.
- Filtrage par corrélation : Ici, on supprime les features qui sont hautement corrélées entre elles, en conservant celle qui est la plus corrélée avec la cible.
- Tests statistiques : Des tests comme l'ANOVA ou le chi carré permettent de mesurer la relation entre les features et la variable cible, éliminant celles qui ne montrent pas de lien significatif.
- Importance par arbres : Les modèles d'arbres de décision, comme les forêts aléatoires, fournissent une mesure d'importance pour chaque feature en fonction de leur contribution à la réduction de l'impureté dans les décisions.
- Régularisation L1 : Cette technique pénalise les coefficients des features dans un modèle, conduisant à une réduction de la dimensionnalité en mettant à zéro les coefficients des features non significatives.
- Élimination récursive : Cette approche consiste à entraîner un modèle à plusieurs reprises, en supprimant les features les moins importantes à chaque étape, jusqu'à obtenir un ensemble optimal.
Pour obtenir un classement global des features, il est essentiel de fusionner les scores issus de ces différentes méthodes. Cela permet de créer un score d'importance combiné qui vous guidera vers la sélection des features les plus pertinentes.
Voici un exemple de code Python illustrant ce pipeline de sélection multi-critères :
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
import pandas as pd
# Charger les données
data = load_iris()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target
# Modèle d'importance
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 : ", X.columns[selector.get_support()])
En appliquant ces techniques, vous vous assurez de maximiser la performance de votre modèle tout en réduisant la complexité, ce qui est essentiel dans le monde du machine learning.
Prêt à automatiser votre feature engineering pour booster vos modèles ?
Ces cinq scripts Python ciblent les étapes clés du feature engineering avec une approche automatisée et intelligente. Vous gagnez du temps, évitez les erreurs manuelles et améliorez vos modèles grâce à des features mieux encodées, transformées, enrichies par interactions, temporalisées et sélectionnées. En intégrant ces outils dans votre workflow, vous passez d’un bricolage fastidieux à une ingénierie rigoureuse et performante, indispensable à toute data science sérieuse.
FAQ
Pourquoi l'encodage automatique des variables catégorielles est-il important ?
Comment choisir la meilleure transformation pour une variable numérique ?
Quels types d'interactions de features sont les plus utiles ?
Pourquoi extraire automatiquement les features temporelles ?
Comment éviter le surapprentissage avec trop de features ?
A propos de l'auteur
Consultant expert en Analytics, Data et Automatisation IA, je suis Franck Scandolera. Fort d’une longue expérience dans le développement d’applications IA et l’intégration de workflows intelligents, je forme et accompagne les professionnels à maîtriser la data science avancée. Basé à Brive-la-Gaillarde, j’interviens en France, Suisse et Belgique pour transformer vos données en avantage compétitif.
⭐ 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.