[PYTHON] Remarques sur l'utilisation des featuretools

Que sont les outils de fonctionnalités

Si vous avez des connaissances sur le domaine cible lors de l'exécution de l'apprentissage automatique, vous pouvez améliorer la précision en considérant une quantité de fonctionnalités appropriée et en la donnant comme une quantité de fonctionnalités, mais même si vous ne connaissez pas le domaine, vous pouvez ajouter ou agréger Vous pouvez vous attendre à trouver le montant de la fonctionnalité par hasard. Puisqu'il s'agit d'une approche circulaire consistant à essayer toutes les combinaisons possibles, cela semble s'appeler l'ingénierie des fonctionnalités de force brute.

featuretools est une bibliothèque python qui semi-automatise la création de fonctionnalités gênantes si elle est effectuée manuellement. très pratique.

Tutoriel officiel featuretools https://docs.featuretools.com/en/stable/

Dans cet article, je suivrai le code de ce blog https://blog.amedama.jp/entry/featuretools-brute-force-feature-engineering

1. install

Entrez avec pip

terminal

pip install featuretools

Vous pouvez également créer un lien avec une autre bibliothèque en installant un module complémentaire. https://docs.featuretools.com/en/stable/install.html

2. Deep Feature Synthesis

Lorsque plusieurs DataFrames sont donnés, les fonctionnalités sont créées en effectuant une agrégation, en calculant des statistiques et en exécutant quatre règles entre les fonctionnalités, et Deep Feature Synthesis effectue ces tâches pour de bon Shioume. Oui, la fonction qui fait cela est featuretools.dfs (). https://docs.featuretools.com/en/stable/getting_started/afe.html

Afin de réaliser cette bonne automatisation de Shioume, il est nécessaire de spécifier un type de données plus détaillé que pandas.DataFrame. Par exemple, il existe Datetime, DateOfBirth, DatetimeTimeIndex, NumericTimeIndex, etc. uniquement pour le type de données qui exprime le temps, ce qui rend difficile la survenue de combinaisons inappropriées. https://docs.featuretools.com/en/stable/getting_started/variables.html

3. Dans le cas d'une seule entité

featuretools appelle l'entité de données d'entrée. Je pense que vous apportez souvent des données avec pandas.DataFrame, mais dans ce cas, un pandas.DataFrame est une entité.

3-1. Trans_primitives uniquement

trans_primitives effectue des calculs entre les entités

Créer un DataFrame à utiliser

python

import pandas as pd
data = {'name': ['a', 'b', 'c'],
        'x': [1, 2, 3],
        'y': [2, 4, 6],
        'z': [3, 6, 9],}
df = pd.DataFrame(data)
df

Créer un EntitySet

Commencez par créer un featuretools.EntitySet vide. EntitySet est un objet permettant de définir la relation entre les entités et le contenu à traiter, mais seul l'identifiant est écrit ci-dessous. L'identifiant peut être omis, mais dans ce qui suit, id = 'exemple'.

python

import featuretools as ft
es = ft.EntitySet(id='example')
es

Ajouter une entité à EntitySet

Dans ce qui suit, le df créé précédemment est enregistré afin qu'il puisse être appelé par le nom «emplacements». index = est un argument pour spécifier l'index tel quel, et s'il est omis, la première colonne de DataFrame est traitée comme index.

python

es = es.entity_from_dataframe(entity_id='locations',
                              dataframe=df,
                              index='name')
es

output

Entityset: example
  Entities:
    locations [Rows: 3, Columns: 4]
  Relationships:
    No relationships

L'entité enregistrée dans EntitySet peut être appelée comme suit

python

es['locations']

output

Entity: locations
  Variables:
    name (dtype: index)
    x (dtype: numeric)
    y (dtype: numeric)
    z (dtype: numeric)
  Shape:
    (Rows: 3, Columns: 4)

python

es['locations'].df

Exécutez dfs

Maintenant que vous avez un EntitySet, tout ce que vous avez à faire est de le transmettre à ft.dfs () pour créer les entités. target_entity est l'entité principale, la méthode de calcul que trans_primitives applique à la combinaison entre les caractéristiques et la méthode de calcul qu'agg_primitives utilise pour l'agrégat.

Les primitives disponibles sont résumées ci-dessous https://primitives.featurelabs.com/

Dans ce qui suit, add_numeric reçoit l'instruction d'ajouter la somme entre les entités et subtract_numeric est invité à ajouter la différence entre les entités.

python

feature_matrix, feature_defs = ft.dfs(entityset=es,
                                      target_entity='locations',
                                      trans_primitives=['add_numeric', 'subtract_numeric'],
                                      agg_primitives=[],
                                      max_depth=1)
feature_matrix

À l'origine, il y avait x, y, z, et la somme d'entre eux x + y, x + z, y + z et la différence x-y, x-z, y-z ont été ajoutées.

3-2. Agrégat uniquement

Pour agg_primitives, spécifiez la méthode de calcul pour créer l'agrégat.

Créer un DataFrame à utiliser

python

data = {'item_id': [1, 2, 3, 4, 5],
        'name': ['apple', 'broccoli', 'cabbage', 'dorian', 'eggplant'],
        'category': ['fruit', 'vegetable', 'vegetable', 'fruit', 'vegetable'],
        'price': [100, 200, 300, 4000, 500]}
item_df = pd.DataFrame(data)
item_df

Vous avez maintenant un DataFrame avec deux variables catégorielles à utiliser pour l'agrégat

Créer un EntitySet

Comme avant jusqu'à ce que l'entité soit ajoutée

python

es = ft.EntitySet(id='example')
es = es.entity_from_dataframe(entity_id='items',
                              dataframe=item_df,
                              index='item_id')
es

Ajoutez ici une relation à utiliser pour l'agrégat.

Dans ce qui suit, il est demandé de créer une nouvelle entité appelée catégorie en fonction de l'entité appelée items et de définir l'index à ce moment comme catégorie.

python

es = es.normalize_entity(base_entity_id='items',
                         new_entity_id='category',
                         index='category')
es

output

Entityset: example
  Entities:
    items [Rows: 5, Columns: 4]
    category [Rows: 2, Columns: 1]
  Relationships:
    items.category -> category.category

Quant à ce qui se passe avec cela, tout d'abord, les éléments sont laissés tels quels.

output

es['items'].df

D'autre part, l'entité appelée category est indexée dans la colonne de catégorie nouvellement spécifiée, c'est donc comme suit.

python

es['category'].df

Exécutez dfs

Essayez de spécifier count, sum, mean pour agg_primitives

python

feature_matrix, feature_defs = ft.dfs(entityset=es,
                                      target_entity='items',
                                      trans_primitives=[],
                                      agg_primitives=['count', 'sum', 'mean'],
                                      max_depth=2)
feature_matrix

Étant donné que la seule colonne qui peut être agrégée est items.price, COUNT (), category.MEAN () et category.SUM () sont calculés respectivement, et un DataFrame avec 3 colonnes supplémentaires est créé.

4. Dans le cas de deux entités

Créer un DataFrame

python

data = {'item_id': [1, 2, 3],
        'name': ['apple', 'banana', 'cherry'],
        'price': [100, 200, 300]}
item_df = pd.DataFrame(data)
item_df

python

from datetime import datetime
data = {'transaction_id': [10, 20, 30, 40],
        'time': [
            datetime(2016, 1, 2, 3, 4, 5),
            datetime(2017, 2, 3, 4, 5, 6),
            datetime(2018, 3, 4, 5, 6, 7),
            datetime(2019, 4, 5, 6, 7, 8),
        ],
        'item_id': [1, 2, 3, 1],
        'amount': [1, 2, 3, 4]}
tx_df = pd.DataFrame(data)
tx_df

Créer un EntitySet

J'ajouterai l'entité comme avant

python

es = ft.EntitySet(id='example')
es = es.entity_from_dataframe(entity_id='items',
                              dataframe=item_df,
                              index='item_id')
es = es.entity_from_dataframe(entity_id='transactions',
                              dataframe=tx_df,
                              index='transaction_id',
                              time_index='time')
es

Créez une relation qui relie les deux entités. Vous fusionnez la colonne item_id des articles et la colonne item_id des transactions.

python

relationship = ft.Relationship(es['items']['item_id'], es['transactions']['item_id'])
es = es.add_relationship(relationship)
es

output

Entityset: example
  Entities:
    items [Rows: 3, Columns: 3]
    transactions [Rows: 4, Columns: 4]
  Relationships:
    transactions.item_id -> items.item_id

Exécutez dfs

python

feature_matrix, feature_defs = ft.dfs(entityset=es,
                                      target_entity='items',
                                      trans_primitives=['add_numeric', 'subtract_numeric'],
                                      agg_primitives=['count', 'sum', 'mean'],
                                      max_depth=2)
feature_matrix

Si vous écrivez uniquement les en-têtes de colonne, cela ressemble à ce qui suit. Il effectue à la fois l'agrégation et le calcul entre les entités.

output

['name',
 'price',
 'COUNT(transactions)',
 'MEAN(transactions.amount)',
 'SUM(transactions.amount)',
 'COUNT(transactions) + MEAN(transactions.amount)',
 'COUNT(transactions) + SUM(transactions.amount)',
 'COUNT(transactions) + price',
 'MEAN(transactions.amount) + SUM(transactions.amount)',
 'MEAN(transactions.amount) + price',
 'price + SUM(transactions.amount)',
 'COUNT(transactions) - MEAN(transactions.amount)',
 'COUNT(transactions) - SUM(transactions.amount)',
 'COUNT(transactions) - price',
 'MEAN(transactions.amount) - SUM(transactions.amount)',
 'MEAN(transactions.amount) - price',
 'price - SUM(transactions.amount)']

Comment fonctionne max_depth

Voyons ce qui se passe si nous augmentons progressivement max_depth avec le code ci-dessus

max_depth=1

['name',
 'price',
 'COUNT(transactions)',
 'MEAN(transactions.amount)',
 'SUM(transactions.amount)']

max_depth=Augmentation de 1 → 2

['COUNT(transactions) + MEAN(transactions.amount)',
 'COUNT(transactions) + SUM(transactions.amount)',
 'COUNT(transactions) + price',
 'MEAN(transactions.amount) + SUM(transactions.amount)',
 'MEAN(transactions.amount) + price',
 'price + SUM(transactions.amount)',
 'COUNT(transactions) - MEAN(transactions.amount)',
 'COUNT(transactions) - SUM(transactions.amount)',
 'COUNT(transactions) - price',
 'MEAN(transactions.amount) - SUM(transactions.amount)',
 'MEAN(transactions.amount) - price',
 'price - SUM(transactions.amount)']

max_depth=Augmentation de 2 → 3

['MEAN(transactions.amount + items.price)',
 'MEAN(transactions.amount - items.price)',
 'SUM(transactions.amount + items.price)',
 'SUM(transactions.amount - items.price)']

max_depth=Augmenter de 3 à 4

['COUNT(transactions) + MEAN(transactions.amount + items.price)',
 'COUNT(transactions) + MEAN(transactions.amount - items.price)',
 'COUNT(transactions) + SUM(transactions.amount + items.price)',
 'COUNT(transactions) + SUM(transactions.amount - items.price)',
 'MEAN(transactions.amount + items.price) + MEAN(transactions.amount - items.price)',
 'MEAN(transactions.amount + items.price) + MEAN(transactions.amount)',
 'MEAN(transactions.amount + items.price) + SUM(transactions.amount + items.price)',
 'MEAN(transactions.amount + items.price) + SUM(transactions.amount - items.price)',
 'MEAN(transactions.amount + items.price) + SUM(transactions.amount)',
 'MEAN(transactions.amount + items.price) + price',
 'MEAN(transactions.amount - items.price) + MEAN(transactions.amount)',
 'MEAN(transactions.amount - items.price) + SUM(transactions.amount + items.price)',
 'MEAN(transactions.amount - items.price) + SUM(transactions.amount - items.price)',
 'MEAN(transactions.amount - items.price) + SUM(transactions.amount)',
 'MEAN(transactions.amount - items.price) + price',
 'MEAN(transactions.amount) + SUM(transactions.amount + items.price)',
 'MEAN(transactions.amount) + SUM(transactions.amount - items.price)',
 'SUM(transactions.amount + items.price) + SUM(transactions.amount - items.price)',
 'SUM(transactions.amount + items.price) + SUM(transactions.amount)',
 'SUM(transactions.amount - items.price) + SUM(transactions.amount)',
 'price + SUM(transactions.amount + items.price)',
 'price + SUM(transactions.amount - items.price)',
 'COUNT(transactions) - MEAN(transactions.amount + items.price)',
 'COUNT(transactions) - MEAN(transactions.amount - items.price)',
 'COUNT(transactions) - SUM(transactions.amount + items.price)',
 'COUNT(transactions) - SUM(transactions.amount - items.price)',
 'MEAN(transactions.amount + items.price) - MEAN(transactions.amount - items.price)',
 'MEAN(transactions.amount + items.price) - MEAN(transactions.amount)',
 'MEAN(transactions.amount + items.price) - SUM(transactions.amount + items.price)',
 'MEAN(transactions.amount + items.price) - SUM(transactions.amount - items.price)',
 'MEAN(transactions.amount + items.price) - SUM(transactions.amount)',
 'MEAN(transactions.amount + items.price) - price',
 'MEAN(transactions.amount - items.price) - MEAN(transactions.amount)',
 'MEAN(transactions.amount - items.price) - SUM(transactions.amount + items.price)',
 'MEAN(transactions.amount - items.price) - SUM(transactions.amount - items.price)',
 'MEAN(transactions.amount - items.price) - SUM(transactions.amount)',
 'MEAN(transactions.amount - items.price) - price',
 'MEAN(transactions.amount) - SUM(transactions.amount + items.price)',
 'MEAN(transactions.amount) - SUM(transactions.amount - items.price)',
 'SUM(transactions.amount + items.price) - SUM(transactions.amount - items.price)',
 'SUM(transactions.amount + items.price) - SUM(transactions.amount)',
 'SUM(transactions.amount - items.price) - SUM(transactions.amount)',
 'price - SUM(transactions.amount + items.price)',
 'price - SUM(transactions.amount - items.price)']

max_depth=Augmentation de 4 → 5

[]

max_depth=Augmenter de 5 à 6

[]

Il semble que ce soit une spécification qui applique agg_primitives, trans_primitives, agg_primitives, trans_primitives et end.

CUSTOM primitives

Il semble que vous puissiez également ajouter votre propre primitive et calculer https://docs.featuretools.com/en/stable/getting_started/primitives.html#simple-custom-primitives

Sommaire

Pratique! !! !!