Implémenter l'ingénierie automatique des fonctionnalités à l'aide de Featuretools

Featuretools est une bibliothèque Python pour l'ingénierie automatisée de fonctionnalités. Il vise à simplifier le processus d’ingénierie des fonctionnalités et à améliorer les performances des modèles d’apprentissage automatique. La bibliothèque peut extraire automatiquement des fonctionnalités utiles à partir de données brutes, aidant ainsi les utilisateurs à gagner du temps et des efforts tout en améliorant la précision du modèle.

Voici les étapes à suivre pour utiliser Featuretools pour automatiser l'ingénierie des fonctionnalités :

Étape 1 : Préparer les données

Avant d'utiliser Featuretools, vous devez préparer l'ensemble de données. L'ensemble de données doit être au format Pandas DataFrame, où chaque ligne représente une observation et chaque colonne représente une fonctionnalité. Pour les problèmes de classification et de régression, l'ensemble de données doit contenir une variable cible, tandis que pour les problèmes de clustering, l'ensemble de données ne nécessite pas de variable cible. Par conséquent, lorsque vous utilisez Featuretools, assurez-vous que l'ensemble de données répond à ces exigences afin que l'ingénierie et la génération de fonctionnalités puissent être effectuées efficacement.

Étape 2 : Définir les entités et les relations

Lorsque vous utilisez Featuretools pour l'ingénierie des fonctionnalités, vous devez d'abord définir les entités et les relations. Une entité est un sous-ensemble d'un ensemble de données qui contient un ensemble de caractéristiques associées. Par exemple, sur un site de commerce électronique, les commandes, les utilisateurs, les produits, les paiements, etc. peuvent être traités comme des entités différentes. Les relations sont des connexions entre des entités. Par exemple, une commande peut être associée à un utilisateur et un utilisateur peut acheter plusieurs produits. En définissant clairement les entités et les relations, la structure de l'ensemble de données peut être mieux comprise, ce qui facilite la génération de fonctionnalités et l'analyse des données.

Étape 3 : Créer un ensemble d'entités

À l'aide de Featuretools, vous pouvez créer un ensemble d'entités en définissant des entités et des relations. Un ensemble d'entités est une collection de plusieurs entités. Dans cette étape, vous devez définir le nom, l'ensemble de données, l'index, le type de variable, l'horodatage, etc. de chaque entité. Par exemple, un ensemble d'entités contenant des entités de commande et d'utilisateur peut être créé à l'aide du code suivant :

import featuretools as ft

# Create entity set
es=ft.EntitySet(id='ecommerce')

# Define entities
orders=ft.Entity(id='orders',dataframe=orders_df,index='order_id',time_index='order_time')
users=ft.Entity(id='users',dataframe=users_df,index='user_id')

# Add entities to entity set
es=es.entity_from_dataframe(entity_id='orders',dataframe=orders_df,index='order_id',time_index='order_time')
es=es.entity_from_dataframe(entity_id='users',dataframe=users_df,index='user_id')

Ici, nous utilisons EntitySet pour créer un ensemble d'entités nommé "ecommerce" et définir deux entités en utilisant Entity, Orders et Users. . Pour l’entité de commande, nous avons spécifié l’ID de commande comme index et l’heure de la commande comme horodatage. Pour l’entité utilisateur, nous avons uniquement spécifié l’ID utilisateur comme index.

Étape 4 : Définir les relations

Dans cette étape, vous devez définir les relations entre les entités. À l'aide de Featuretools, les relations peuvent être définies via des variables partagées, des horodatages, etc. entre les entités. Par exemple, sur un site e-commerce, chaque commande est associée à un utilisateur. La relation entre les commandes et les utilisateurs peut être définie à l'aide du code suivant :

# Define relationships
r_order_user = ft.Relationship(orders['user_id'], users['user_id'])
es = es.add_relationship(r_order_user)

Ici, nous avons défini la relation entre les commandes et les utilisateurs à l'aide de Relation et les avons ajoutées à l'ensemble d'entités à l'aide de add_relationship.

Étape 5 : Exécutez l'algorithme de synthèse approfondie des fonctionnalités

Après avoir terminé les étapes ci-dessus, vous pouvez utiliser l'algorithme de synthèse approfondie des fonctionnalités de Featuretools pour générer automatiquement des fonctionnalités. Cet algorithme crée automatiquement de nouvelles fonctionnalités telles que des agrégations, des transformations et des combinaisons. Vous pouvez utiliser le code suivant pour exécuter l'algorithme de synthèse de fonctionnalités approfondies :

# Run deep feature synthesis algorithm
features, feature_names = ft.dfs(entityset=es, target_entity='orders', max_depth=2)

Ici, nous utilisons la fonction dfs pour exécuter l'algorithme de synthèse de fonctionnalités approfondies, spécifions l'entité cible comme entité de commande et définissons la profondeur maximale sur 2. La fonction renvoie un DataFrame contenant les nouvelles fonctionnalités et une liste de noms de fonctionnalités.

Étape 6 : Construire le modèle

Après avoir obtenu les nouvelles fonctionnalités, vous pouvez les utiliser pour entraîner le modèle d'apprentissage automatique. De nouvelles fonctionnalités peuvent être ajoutées à l'ensemble de données d'origine à l'aide du code suivant :

# Add new features to original dataset
df=pd.merge(orders_df,features,left_on='order_id',right_on='order_id')

Ici, nous utilisons la fonction de fusion pour ajouter de nouvelles fonctionnalités à l'ensemble de données d'origine à des fins de formation et de test. Les nouvelles fonctionnalités peuvent ensuite être utilisées pour entraîner le modèle d'apprentissage automatique, par exemple :

# Split dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(df[feature_names], df['target'], test_size=0.2, random_state=42)

# Train machine learning model
model = RandomForestClassifier()
model.fit(X_train, y_train)

# Evaluate model performance
y_pred = model.predict(X_test)
accuracy_score(y_test, y_pred)

Ici, nous utilisons le classificateur de forêt aléatoire comme modèle d'apprentissage automatique et utilisons l'ensemble d'entraînement pour entraîner le modèle. Nous utilisons ensuite l'ensemble de tests pour évaluer les performances du modèle, en utilisant la précision comme mesure d'évaluation.

Résumé :

Les étapes à suivre pour utiliser Featuretools pour automatiser l'ingénierie des fonctionnalités comprennent la préparation des données, la définition des entités et des relations, la création d'ensembles d'entités, la définition des relations, l'exécution d'algorithmes de synthèse de fonctionnalités approfondies et la création de modèles. Featuretools peut extraire automatiquement des fonctionnalités utiles à partir de données brutes, aidant ainsi les utilisateurs à économiser beaucoup de temps et d'efforts et à améliorer les performances des modèles d'apprentissage automatique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!