Comment automatiser le feature engineering en Python efficacement ?

Automatiser le feature engineering en Python est possible grâce à des scripts ciblés qui simplifient l’encodage, la transformation, la génération d’interactions, l’extraction temporelle et la sélection de variables. Découvrez comment ces outils optimisent vos modèles sans perdre de temps.

3 principaux points à retenir.

• Automatisation ciblée : scripts spécialisés pour chaque étape clé du feature engineering.
• Optimisation des performances : sélection intelligente des meilleures transformations et interactions.
• Robustesse et reproductibilité : gestion cohérente des données, évitant erreurs et fuites de données.

Pourquoi automatiser l’encodage des variables catégorielles

Automatiser l’encodage des variables catégorielles est crucial pour gagner en fiabilité et éviter les pièges classiques comme la fuite de données ou la gestion des catégories rares. Les variables catégorielles sont omniprésentes dans les jeux de données, mais leur traitement est souvent source de confusion. Chaque méthode d’encodage a ses spécificités, et choisir la bonne selon le contexte peut faire la différence entre un modèle performant et un modèle à la traîne.

Le script d’encodage automatique analyse d’abord la cardinalité de chaque variable. Pour les variables à faible cardinalité (moins de 10 valeurs uniques), il applique le one-hot encoding, qui transforme chaque catégorie en une colonne binaire. C’est efficace, mais attention à la dimensionnalité si vous avez trop de catégories. Pour les variables à haute cardinalité (plus de 50 valeurs), le script opte pour le fréquence encoding, qui remplace chaque catégorie par son nombre d’occurrences. Cela réduit la complexité tout en préservant l’information essentielle.

Pour les variables qui montrent une correlation forte avec la cible, le target encoding est privilégié. Cette méthode remplace chaque catégorie par la moyenne de la cible pour cette catégorie, mais attention à la fuite de données si elle n’est pas gérée correctement. Enfin, pour les variables ordinales, le label encoding est utilisé, assignant un numéro à chaque catégorie en respectant leur ordre.

Découvrez égalementComment réussir le prétraitement des données en Python ?

Un autre aspect essentiel est la gestion des catégories rares. Le script regroupe automatiquement les catégories qui apparaissent dans moins de 1% des lignes dans une catégorie « autre ». Cela permet de garder le modèle propre et évite que des catégories peu fréquentes n’influencent trop les résultats.

Voici un exemple simple d’encodage automatique :

import pandas as pd
from category_encoders import TargetEncoder

# Exemple de DataFrame
data = pd.DataFrame({
    'category': ['A', 'B', 'A', 'C', 'B', 'A', 'D'],
    'target': [1, 0, 1, 0, 1, 1, 0]
})

# Application du Target Encoding
encoder = TargetEncoder(cols=['category'])
data['encoded'] = encoder.fit_transform(data['category'], data['target'])
print(data)

En résumé, le choix de la méthode d’encodage dépend de la nature des variables, de leur cardinalité et de leur relation avec la cible. Un tableau synthétique peut vous aider à choisir la méthode adéquate :

Comment transformer efficacement les variables numériques

La transformation des variables numériques est un passage obligé pour quiconque souhaite optimiser ses modèles. Pourquoi ? Parce que des distributions biaisées, des valeurs extrêmes ou des échelles disparates peuvent gravement nuire à la performance de votre modèle. Et ne vous y trompez pas, manuellement tester des transformations pour chaque variable est non seulement fastidieux, mais aussi source d’erreurs. C’est là qu’un bon script entre en jeu.

Ce script s’attaque à plusieurs transformations courantes : log, Box-Cox, racines carrées, standardisation, robust scaling ou encore Yeo-Johnson. Mais comment ça fonctionne concrètement ? Le script commence par évaluer chaque variable numérique en appliquant des tests de normalité, comme le test de Shapiro-Wilk ou l’Anderson-Darling. Cela permet de vérifier si la distribution est suffisamment proche d’une distribution normale.

Découvrez égalementQuels Docker containers pour une petite entreprise ?

Pour chaque variable, le script teste différentes transformations et sélectionne celle qui réduit le mieux l’asymétrie. Par exemple, si une variable présente une skewness supérieure à 1, le script priorise les transformations logarithmiques ou Box-Cox. En cas de valeurs négatives ou nulles, il utilise des transformations adaptées, comme Yeo-Johnson, qui fonctionnent pour toutes les valeurs réelles.

Voici un exemple de code pour transformer une variable numérique :

import pandas as pd
from sklearn.preprocessing import PowerTransformer

# Exemple de dataframe
data = pd.DataFrame({'variable': [1, 2, 3, 4, 5, 100]})

# Création et application du transformateur
pt = PowerTransformer(method='yeo-johnson')
data['variable_transformed'] = pt.fit_transform(data[['variable']])
print(data)

Ce script vous permet non seulement de transformer vos variables, mais aussi d’appliquer les transformations de manière cohérente sur vos ensembles de données d’entraînement et de test. Voilà un outil qui vous fera gagner un temps précieux tout en améliorant vos modèles.

Pour mieux comprendre les différentes méthodes de transformation, voici un tableau comparatif :

Découvrez égalementComment créer un analyste financier privé en local ?

En résumé, ne sous-estimez pas l’importance de transformer vos variables numériques. Avec ce script, vous avez une arme redoutable pour améliorer la performance de vos modèles, tout en économisant un temps précieux. Pour en savoir plus sur les transformations, vous pouvez consulter cette vidéo ici.

Quels bénéfices tirer de la génération automatique d’interactions de features

Les interactions entre features, c’est le genre de pépite que les modèles linéaires simples ont tendance à ignorer. Pourtant, elles peuvent révéler des signaux complexes qui boostent vos performances de manière significative. Imaginez que vous ayez une variable sur les dépenses publicitaires et une autre sur les segments de clients : la façon dont ces deux éléments interagissent peut être bien plus révélatrice que chacune d’elles prise individuellement.

Le script que nous allons explorer ici automatise la génération de ces interactions. Il crée des produits, des ratios, des sommes et des différences pour les features numériques, tout en combinant les features catégorielles. Mais comment savoir si ces interactions sont réellement pertinentes ? C’est là que l’évaluation entre en jeu. Nous utilisons l’information mutuelle ou l’importance dans un modèle random forest pour jauger la valeur prédictive de chaque interaction.

Voici un extrait de code qui illustre comment générer et filtrer ces interactions :

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import mutual_info_classif

def generate_interactions(df, target):
    interactions = []
    for i in range(len(df.columns)):
        for j in range(i + 1, len(df.columns)):
            if df.columns[i] != target and df.columns[j] != target:
                interactions.append(df[df.columns[i]] * df[df.columns[j]])
    return pd.DataFrame(interactions, columns=[f"{df.columns[i]}_times_{df.columns[j]}" for i in range(len(df.columns)) for j in range(i + 1, len(df.columns))])

# Exemple d'utilisation
df = pd.DataFrame({'feature1': [1, 2, 3], 'feature2': [4, 5, 6], 'target': [0, 1, 0]})
interaction_df = generate_interactions(df, 'target')
model = RandomForestClassifier()
model.fit(interaction_df, df['target'])
importances = model.feature_importances_

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

Ce code génère des interactions entre toutes les features, puis évalue leur impact via un modèle random forest. À partir de là, vous pouvez filtrer les interactions en fonction de leur importance. En conservant uniquement les plus impactantes, vous limitez l’explosion des dimensions tout en capturant l’essentiel.

Pour résumer, voici un tableau des types d’interactions et de leur impact potentiel :

En intégrant ces interactions dans votre pipeline de feature engineering, vous vous donnez les moyens d’extraire des insights précieux, souvent invisibles au premier abord. Pour aller plus loin, vous pouvez consulter des ressources complémentaires comme ce lien.

Comment extraire automatiquement les informations temporelles des dates

Les colonnes datetime recèlent un trésor d’informations souvent sous-exploitées. Pour maximiser leur potentiel, il est crucial d’extraire des composantes clés et des indicateurs pertinents. Un script performant peut automatiser cette tâche fastidieuse et vous faire gagner un temps précieux.

Découvrez égalementQuels cours SQL gratuits offrent un certificat reconnu ?

Le script que nous allons examiner extrait automatiquement les composantes classiques comme l’année, le mois, le jour et l’heure. Mais ce n’est pas tout : il génère aussi des indicateurs calendaires tels que les week-ends et les jours fériés. En outre, il crée des codages cycliques, par exemple en utilisant les transformations sine et cosine pour les mois et les heures, afin de conserver la continuité dans les données.

Pourquoi ces codages cycliques sont-ils si importants ? En effet, ils permettent de représenter des données qui ont une nature circulaire. Par exemple, décembre (12) et janvier (1) sont des mois consécutifs, mais si vous les traitez comme des valeurs linéaires, vous risquez de perdre cette relation. Voici les formules utilisées :

month_sin = sin(2 * pi * month / 12)
month_cos = cos(2 * pi * month / 12)
hour_sin = sin(2 * pi * hour / 24)
hour_cos = cos(2 * pi * hour / 24)

Le script gère également les différences entre les dates, ce qui est essentiel pour des analyses temporelles précises. Par exemple, il peut calculer le nombre de jours écoulés entre deux événements, ce qui peut être déterminant dans des domaines comme la finance ou le marketing.

Pour illustrer l’extraction complète d’une colonne datetime, voici un exemple de code :

import pandas as pd

# Exemple de DataFrame
df = pd.DataFrame({'date': ['2023-01-01 12:00:00', '2023-01-02 13:30:00']})
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['weekend'] = df['date'].dt.dayofweek >= 5

Voici un tableau synthétique des features temporelles générées :

En automatisant l’extraction des informations temporelles, vous vous assurez de ne pas manquer ces signaux précieux qui peuvent améliorer considérablement la performance de vos modèles. Pour en savoir plus, consultez cet article sur l’automatisation de l’ingénierie des caractéristiques temporelles.

Comment sélectionner automatiquement les meilleures features pour votre modèle

Après avoir généré des centaines de features, il faut trier le bon grain de l’ivraie. La sélection automatique des meilleures features est cruciale pour éviter la surcharge de votre modèle et garantir des performances optimales. C’est ici qu’intervient un pipeline multi-critères qui vous permet de faire le tri efficacement.

La première étape consiste à éliminer les variables à faible variance. Ces features, qui ne changent pas beaucoup entre les observations, n’apportent aucune information utile. Ensuite, on passe à la suppression des redondances via l’analyse des corrélations. En effet, deux features fortement corrélées peuvent introduire du bruit dans votre modèle. La solution ? Gardez celle qui est la plus corrélée avec la variable cible.

Ensuite, on utilise des tests statistiques comme l’ANOVA et le chi-square pour évaluer l’importance des features. Ces tests vous aident à identifier celles qui ont un impact significatif sur la variable cible. En parallèle, l’importance des features peut être évaluée via des modèles basés sur des arbres, qui calculent des scores d’importance basés sur la capacité de chaque feature à réduire l’erreur.

Un autre outil puissant est la régularisation L1, qui pénalise les coefficients des features dans le modèle, poussant certains à zéro. Cela permet non seulement de réduire le nombre de features, mais aussi d’améliorer la généralisation du modèle. Enfin, l’élimination récursive des features (RFE) permet d’identifier le sous-ensemble optimal en entraînant le modèle plusieurs fois, à chaque fois en retirant les features les moins importantes.

Voici un exemple de code pour réaliser cette sélection automatique :

import pandas as pd
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier

# Chargement des données
X = pd.read_csv('data.csv')
y = X.pop('target')

# Entraînement d'un modèle pour l'importance des features
model = RandomForestClassifier()
model.fit(X, y)

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

Ce pipeline vous permet de conserver uniquement les features les plus pertinentes, réduisant ainsi le risque de surapprentissage et augmentant la performance de votre modèle. Voici un tableau récapitulatif des méthodes de sélection :

Prêt à booster vos modèles avec une feature engineering automatisée et intelligente ?

Ces cinq scripts Python ciblés représentent un saut qualitatif pour toute pratique de machine learning. Ils automatisent les étapes clés du feature engineering, de l’encodage à la sélection, en passant par la transformation et la génération d’interactions, tout en garantissant robustesse et cohérence. Cette approche vous fait gagner un temps précieux, réduit les erreurs humaines, et maximise la performance de vos modèles. En adoptant ces outils, vous passez d’une gestion artisanale et hasardeuse à un processus rigoureux, reproductible et optimisé, un vrai atout pour vos projets data.

FAQ

A propos de l’auteur

Franck Scandolera est consultant et formateur expert en Analytics, Data, Automatisation et IA. Fort de nombreuses années à développer des solutions intégrant l’IA dans des workflows métier, il accompagne les entreprises dans l’optimisation de leurs processus data-driven. Responsable de l’agence webAnalyste et de l’organisme de formation Formations Analytics, Franck partage son expertise pointue et pragmatique pour rendre accessibles les techniques avancées de data science et d’automatisation.

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.