Comment automatiser le feature engineering en Python efficacement ?

Par

Automatiser le feature engineering en Python, c’est possible et ça booste vos modèles. Découvrez comment cinq scripts ciblés simplifient encoding, transformation, interactions, extraction temporelle et sélection, pour gagner en performance sans perdre de temps.

3 principaux points à retenir.

  • Automatisation ciblée : cinq scripts Python couvrent les tâches clés du feature engineering.
  • Performance accrue : chaque script améliore la qualité des features pour des modèles plus précis.
  • Simplicité et robustesse : gestion intelligente des encodages, transformations et sélections sans erreurs.

Comment gérer efficacement les variables catégorielles en Python ?

Les variables catégorielles, vous les croisez partout dans vos jeux de données. Que ce soit pour identifier des clients, des produits ou des événements, leur encodage est essentiel pour que vos modèles de machine learning puissent les comprendre. Mais attention, l’encodage des variables catégorielles n’est pas une mince affaire. Prenons quelques méthodes classiques pour mieux comprendre les enjeux.

  • One-hot encoding : Idéal pour les variables à faible cardinalité. Cependant, cette méthode peut rapidement devenir problématique avec les catégories à forte cardinalité, entraînant une explosion dimensionnelle.
  • Label encoding : Économique en mémoire, mais il impose un ordre qui n’existe pas nécessairement dans vos données, ce qui peut induire des biais dans vos modèles.
  • Target encoding : Puissant, certes, mais attention à la fuite de données. Si vous ne faites pas attention, vous risquez d’introduire des biais dans votre modèle en utilisant des informations de la variable cible.

Pour pallier ces limites, un script Python peut être votre meilleur allié. Ce script analyse automatiquement la cardinalité des variables catégorielles et leur corrélation avec la cible. En fonction des résultats, il choisit la méthode d’encodage la plus adaptée : one-hot pour les faibles cardinalités, fréquence pour les hautes, label pour les ordonnées, et target encoding pour les corrélées.

Un autre problème courant est la gestion des catégories rares et inconnues. La clé est de regrouper ces catégories peu fréquentes dans une catégorie « autres » pour éviter les erreurs en production. Cela garantit que votre modèle reste robuste face aux données nouvelles.

Entre nous, on le sait bien, faire appel à un consultant en automatisation intelligente et en agent IA, c’est souvent le raccourci le plus malin. On en parle ?

Read moreComment accéder et utiliser Qwen3-Coder-Next efficacement ?

Voici un exemple simple de code qui met en œuvre ces encodages conditionnels :

import pandas as pd
from category_encoders import TargetEncoder

def encode_categorical_features(df, target):
    for col in df.select_dtypes(include=['object']).columns:
        cardinality = df[col].nunique()
        if cardinality < 10:
            df = pd.get_dummies(df, columns=[col], drop_first=True)
        elif cardinality < 50:
            df[col] = df[col].astype('category')
        else:
            encoder = TargetEncoder(cols=[col])
            df[col] = encoder.fit_transform(df[col], df[target])
    return df

Ce code illustre comment appliquer des encodages en fonction de la cardinalité de chaque variable. En stockant les mappings, on assure une cohérence entre les jeux d'entraînement et de test, ce qui est crucial pour la performance de vos modèles. Pour plus d'informations sur la gestion des variables, consultez cet article ici.

Comment transformer automatiquement les variables numériques ?

Les variables numériques brutes peuvent vraiment fausser vos modèles de machine learning. Pourquoi ? Parce qu'elles ne sont pas toujours adaptées à l'analyse directe. Souvent, elles nécessitent des transformations pour être véritablement utiles. Alors, quelles transformations utiliser ? Voici les principales :

  • Logarithmique : Utile pour réduire l'impact des valeurs extrêmes.
  • Box-Cox : Transforme les données pour qu'elles suivent une distribution normale.
  • Racine carrée : Réduit la variance dans des données fortement biaisées.
  • Standardisation : Met à l'échelle les données pour qu'elles aient une moyenne de zéro et un écart type de un.
  • Robust Scaling : Utilise les statistiques robustes pour traiter les outliers.
  • Power Transformations : Améliore la normalité des données.

Le script que vous allez utiliser testera ces options sur chaque variable. Comment cela fonctionne-t-il ? Il commence par évaluer la normalité des données en utilisant des tests comme Shapiro-Wilk ou Anderson-Darling. Ensuite, il choisit la meilleure transformation. Cela permet de s'assurer que votre modèle n'est pas biaisé par des distributions non normales.

Read moreQuels sont les meilleurs serveurs MCP pour construire en IA en 2026 ?

Et qu'en est-il des valeurs négatives ou nulles ? Pas de panique. Le script gère ces cas avec finesse, en utilisant des transformations comme Yeo-Johnson ou en décalant les valeurs pour éviter les erreurs de transformation. Cela garantit que même les données les plus délicates sont traitées correctement.

Voici un exemple de code qui applique ces transformations et conserve les paramètres pour les tests :

from sklearn.preprocessing import PowerTransformer
import pandas as pd

# Exemple de données
data = pd.DataFrame({'feature': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})

# Appliquer la transformation
pt = PowerTransformer(method='yeo-johnson')
data['transformed'] = pt.fit_transform(data[['feature']])

# Enregistrer les paramètres pour les tests
params = pt.get_params()

Automatiser ce processus vous permet d'éviter des itérations manuelles longues et des erreurs potentielles. En fin de compte, cela vous fait gagner du temps et améliore la qualité de votre modèle. Pour voir d'autres astuces, n'hésitez pas à consulter cette vidéo.

Comment générer et sélectionner les interactions de features pertinentes ?

Les interactions entre features peuvent être de véritables mines d'or pour vos modèles, révélant des signaux cachés que les variables prises individuellement ne pourraient jamais mettre en lumière. Pensez-y : la manière dont deux variables interagissent peut souvent être plus informative que leur contribution isolée. Cependant, le défi réside dans la combinatoire explosante des interactions possibles. Tester toutes les paires de features devient vite un casse-tête ingérable, surtout si vous avez des dizaines, voire des centaines de variables.

Read morePourquoi les pubs d'Anthropic sur OpenAI font-elles débat ?

C'est là qu'intervient notre script de génération et de sélection d'interactions de features. Ce dernier automatise la création de produits, de ratios, de sommes et de différences pour les variables numériques, tout en générant des combinaisons pour les variables catégorielles. En d'autres termes, il vous permet d'explorer systématiquement les interactions sans vous noyer sous un océan de combinaisons impossibles à gérer.

Pour évaluer la pertinence de ces nouvelles interactions, le script utilise des mesures telles que l'information mutuelle ou l'importance d'un modèle de type random forest. Ces méthodes permettent de scorer chaque interaction en fonction de sa capacité à prédire la variable cible. Ensuite, seules les interactions les plus prometteuses sont retenues, soit en fonction d'un seuil prédéfini, soit en sélectionnant les meilleures N interactions.

En matière de robustesse, le script sait aussi gérer les cas limites, comme la division par zéro ou les valeurs infinies, garantissant ainsi que vous ne tombiez pas dans des pièges classiques lors de l'évaluation de vos interactions.


import pandas as pd
import numpy as np
from sklearn.feature_selection import mutual_info_regression
from sklearn.ensemble import RandomForestRegressor

# Exemple de génération d'interactions
def generate_interactions(df, target):
    interactions = pd.DataFrame()
    numeric_features = df.select_dtypes(include=[np.number]).columns.tolist()
    
    for i in range(len(numeric_features)):
        for j in range(i+1, len(numeric_features)):
            interactions[f'{numeric_features[i]}_x_{numeric_features[j]}'] = (
                df[numeric_features[i]] * df[numeric_features[j]]
            )
    
    # Scoring des interactions
    scores = {}
    for col in interactions.columns:
        scores[col] = mutual_info_regression(interactions[[col]], df[target])
    
    # Sélection des meilleures interactions
    top_n = sorted(scores, key=scores.get, reverse=True)[:10]
    
    return interactions[top_n]

# Utilisation
df = pd.DataFrame(...)  # Votre DataFrame ici
target = 'votre_variable_cible'
best_interactions = generate_interactions(df, target)

Voici un tableau synthétique des types d'interactions et des méthodes de sélection utilisées :

Type d'interaction Méthode de sélection
Produits Information mutuelle
Ratios Importance des forêts aléatoires
Sommes Seuil de pertinence
Différences Top N interactions

Comment extraire automatiquement les features temporelles utiles ?

Read moreVotre pipeline ML est-il vraiment optimisé pour la performance ?

Les données datetime sont souvent une mine d'or d'informations, mais elles restent sous-exploitées à cause de l'extraction manuelle qui nécessite un investissement de temps considérable. En effet, chaque colonne datetime peut receler une multitude d'indicateurs précieux. Alors, qu'est-ce qu'on peut extraire ? Commençons par les éléments de base : l'année, le mois, le jour et l'heure. Ces informations sont essentielles, mais ne s'arrêtent pas là.

Il existe également des extractions avancées, comme le jour de la semaine, le trimestre ou encore des indicateurs pour les week-ends. Ces éléments peuvent avoir un impact significatif sur le comportement des utilisateurs ou le volume de ventes, par exemple. En intégrant ces détails, vous pouvez donner à votre modèle une compréhension plus fine des tendances temporelles.

Un autre aspect souvent négligé est l'utilisation de codages cycliques pour des variables comme le mois ou l'heure. En appliquant des transformations sinusoïdales, par exemple, vous préservez la continuité cyclique, ce qui est crucial pour les modèles de machine learning. Pour le mois, on pourrait utiliser :

month_sin = np.sin(2 * np.pi * month / 12)

Cette approche garantit que décembre et janvier sont rapprochés dans l'espace des caractéristiques, ce qui est logique dans un contexte temporel.

Read moreQuelles sont les meilleures bibliothèques Python pour l'IA et le Machine Learning ?

En outre, il est important de calculer les deltas temporels entre différentes dates. Cela peut être particulièrement utile pour analyser le temps écoulé entre des événements, comme le délai de livraison. Vous pourriez également gérer les vacances et jours spéciaux, en ajoutant des indicateurs boolean pour ces dates. Cela permet de capturer des effets saisonniers ou des comportements atypiques lors de certaines périodes de l'année.

Pour illustrer, voici un exemple Python simple qui extrait ces caractéristiques d'une colonne datetime :


import pandas as pd
import numpy as np

# Exemple de DataFrame avec une colonne datetime
df = pd.DataFrame({
    'date': pd.to_datetime(['2023-01-01', '2023-06-15', '2023-12-25'])
})

# Extraction des caractéristiques
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['day_of_week'] = df['date'].dt.dayofweek
df['is_weekend'] = np.where(df['day_of_week'] >= 5, 1, 0)
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)

En automatisant ces extractions, vous gagnez non seulement du temps, mais vous enrichissez également votre modèle avec des caractéristiques pertinentes qui peuvent améliorer sa performance. Pour aller plus loin, vous pouvez consulter des ressources supplémentaires sur ce sujet ici.

Comment sélectionner automatiquement les meilleures features ?

Le feature engineering peut rapidement devenir un véritable casse-tête, surtout quand on se retrouve avec une multitude de variables, dont une bonne partie est redondante ou carrément inutile. Pour faire le tri, un script bien ficelé peut faire toute la différence. Ce dernier ne se contente pas de balayer les données, il combine plusieurs méthodes efficaces pour sélectionner les meilleures features.

Le processus commence par un filtrage par variance. Ce premier filtre permet de se débarrasser des features qui n'apportent aucune information, c'est-à-dire celles qui ont une variance nulle ou proche de zéro. Ensuite, on passe à la suppression des corrélations fortes. En effet, si deux features sont fortement corrélées, l'une d'elles peut être éliminée sans perte d'information, ce qui aide à réduire la redondance.

Le script intègre également des tests statistiques comme l'ANOVA, le chi carré, et l'information mutuelle. Ces tests permettent d'évaluer la relation entre les features et la variable cible, ce qui est crucial pour la performance du modèle. Mais ce n’est pas tout : l’importance des features est également mesurée à l'aide d'arbres de décision et de la régularisation L1, qui pénalise les coefficients des features moins pertinentes.

Pour couronner le tout, une élimination récursive des features (Recursive Feature Elimination - RFE) est effectuée. Ce processus permet de déterminer le nombre optimal de features à retenir, en s'appuyant sur la validation croisée pour éviter le surapprentissage. Les résultats de toutes ces méthodes sont normalisés et combinés en un score d’ensemble, garantissant ainsi un classement robuste des features.

Voici un exemple de code qui exécute ce pipeline :

from sklearn.feature_selection import VarianceThreshold, SelectKBest, chi2
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
import pandas as pd

# Chargement des données
data = pd.read_csv('data.csv')
X = data.drop('target', axis=1)
y = data['target']

# Filtrage par variance
selector = VarianceThreshold(threshold=0.01)
X_filtered = selector.fit_transform(X)

# Sélection par chi2
X_chi2 = SelectKBest(chi2, k=10).fit_transform(X_filtered, y)

# Importance par Random Forest
model = RandomForestClassifier()
model.fit(X_chi2, y)
importances = model.feature_importances_

# Validation croisée pour déterminer le nombre optimal de features
scores = cross_val_score(model, X_chi2, y, cv=5)
print(f'Accuracy: {scores.mean()}')

Avec cette approche, vous réduisez la dimensionnalité de votre jeu de données tout en améliorant la performance de votre modèle. C'est une manière astucieuse de tirer le meilleur parti de vos données, sans se perdre dans une mer de variables inutiles.

Prêt à automatiser votre feature engineering pour gagner en efficacité ?

Ces cinq scripts Python ciblés révolutionnent votre feature engineering en automatisant les tâches les plus chronophages et techniques. De l’encodage intelligent des catégories à la transformation optimale des numériques, en passant par la génération d’interactions, l’extraction temporelle complète et la sélection rigoureuse des features, vous disposez d’un arsenal pour maximiser la performance de vos modèles. En intégrant ces outils, vous gagnez du temps, réduisez les erreurs et améliorez la qualité de vos données. Résultat : vos projets ML avancent plus vite et plus fort, avec des features qui font vraiment la différence.

FAQ

Pourquoi automatiser le feature engineering en machine learning ?

Automatiser le feature engineering réduit le temps passé sur des tâches répétitives, minimise les erreurs humaines et permet d’explorer plus rapidement des combinaisons de features, améliorant ainsi la performance des modèles.

Comment gérer les catégories rares ou inconnues lors de l’encodage ?

Les scripts regroupent les catégories rares sous un label 'other' et gèrent les catégories inconnues en test en leur attribuant cette même catégorie ou une valeur moyenne, évitant ainsi les erreurs et garantissant la cohérence.

Quelle transformation numérique choisir pour une variable skewée ?

Pour une variable avec forte asymétrie, le script privilégie les transformations log ou Box-Cox, qui normalisent la distribution et améliorent la modélisation.

Comment savoir quelles interactions de features sont utiles ?

Le script évalue les interactions via l’information mutuelle ou l’importance dans un modèle random forest, ne conservant que celles qui apportent une valeur prédictive significative.

Pourquoi utiliser plusieurs méthodes de sélection de features ?

Combiner plusieurs méthodes évite les biais d’une méthode unique et produit un classement plus fiable des features, garantissant une sélection optimale pour la performance et la simplicité du modèle.

 

 

A propos de l'auteur

Franck Scandolera, fort de plusieurs années d’expérience en analytics et data science, accompagne les entreprises dans la mise en œuvre d’automatisations avancées et d’intégration IA. Expert reconnu en feature engineering, traitement de données et automatisation via n8n et API OpenAI, il partage ses compétences pour optimiser vos workflows data et booster vos modèles prédictifs.

Retour en haut