[PYTHON] Hinweise zur Verwendung von featuretools

Was sind Feature-Tools?

Wenn Sie beim maschinellen Lernen Kenntnisse über die Zieldomäne haben, können Sie die Genauigkeit verbessern, indem Sie eine geeignete Feature-Menge berücksichtigen und als Feature-Menge angeben. Selbst wenn Sie keine Domain-Kenntnisse haben, können Sie diese hinzufügen oder aggregieren Sie können die Strategie verfolgen, zu erwarten, dass der Funktionsumfang zufällig ermittelt wird. Da es sich um einen Round-Robin-Ansatz handelt, bei dem alle möglichen Kombinationen ausprobiert werden, scheint es sich um Brute-Force-Feature-Engineering zu handeln.

featuretools ist eine Python-Bibliothek, die die mühsame Erstellung von Features halbautomatisiert, wenn sie manuell ausgeführt wird. sehr angenehm.

featuretools offizielles Tutorial https://docs.featuretools.com/en/stable/

In diesem Artikel werde ich dem Code dieses Blogs folgen https://blog.amedama.jp/entry/featuretools-brute-force-feature-engineering

1. install

Mit pip eintreten

terminal

pip install featuretools

Sie können auch eine Verknüpfung mit einer anderen Bibliothek herstellen, indem Sie das Addon zusätzlich installieren. https://docs.featuretools.com/en/stable/install.html

2. Deep Feature Synthesis

Wenn mehrere DataFrames angegeben werden, werden die Features durch Aggregieren, Berechnen von Statistiken und Ausführen von vier Regeln zwischen den Features erstellt. Deep Feature Synthesis erledigt diese Aufgaben für ein gutes Shioume. Ja, die Funktion, die dies tut, ist featuretools.dfs (). https://docs.featuretools.com/en/stable/getting_started/afe.html

Um diese gute Automatisierung von Shioume zu realisieren, muss ein detaillierterer Datentyp als pandas.DataFrame angegeben werden. Beispielsweise gibt es Datetime, DateOfBirth, DatetimeTimeIndex, NumericTimeIndex usw. nur für den Datentyp, der die Zeit ausdrückt, und es macht das Auftreten unangemessener Kombinationen schwierig. https://docs.featuretools.com/en/stable/getting_started/variables.html

3. Im Falle einer Entität

featuretools ruft die Eingabedatenentität auf. Ich denke, dass Sie häufig Daten mit pandas.DataFrame mitbringen, aber in diesem Fall ist ein pandas.DataFrame eine Entität.

3-1. Nur trans_primitives

trans_primitives führt Berechnungen zwischen Features durch

Erstellen Sie einen zu verwendenden DataFrame

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

Erstellen Sie ein EntitySet

Erstellen Sie zunächst ein leeres featuretools.EntitySet. EntitySet ist ein Objekt zum Definieren der Beziehung zwischen Entitäten und dem zu verarbeitenden Inhalt, aber nur die ID wird unten geschrieben. Die ID kann weggelassen werden, aber im Folgenden ist id = 'Beispiel'.

python

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

Entität zu EntitySet hinzufügen

Im Folgenden wird die zuvor erstellte df registriert, damit sie unter dem Namen 'standorte' aufgerufen werden kann. index = ist ein Argument für die Angabe des Index, und wenn er weggelassen wird, wird die erste Spalte von DataFrame als Index behandelt.

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

Die in EntitySet registrierte Entität kann wie folgt aufgerufen werden

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

Führen Sie dfs aus

Nachdem Sie ein EntitySet haben, müssen Sie es nur noch an ft.dfs () übergeben, um die Features zu erstellen. target_entity ist die Hauptentität, die Berechnungsmethode, die trans_primitives auf die Kombination zwischen Features anwendet, und die Berechnungsmethode, die agg_primitives für das Aggregat verwendet.

Die verfügbaren Grundelemente sind nachstehend zusammengefasst https://primitives.featurelabs.com/

Im Folgenden wird add_numeric angewiesen, die Summe zwischen Features zu addieren, und subtract_numeric wird angewiesen, den Unterschied zwischen Features zu addieren.

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

Ursprünglich gab es x, y, z und die Summe von ihnen, x + y, x + z, y + z, und die Differenz x-y, x-z, y-z wurden hinzugefügt.

3-2. Nur aggregieren

Geben Sie für agg_primitives die Berechnungsmethode zum Erstellen eines Aggregats an.

Erstellen Sie einen zu verwendenden DataFrame

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

Sie haben jetzt einen DataFrame mit zwei kategorialen Variablen, die Sie für die Aggregation verwenden können

Erstellen Sie ein EntitySet

Wie zuvor, bis die Entität hinzugefügt wird

python

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

Fügen Sie hier eine Beziehung hinzu, die für das Aggregat verwendet werden soll.

Im Folgenden wird angewiesen, eine neue Entität namens Kategorie basierend auf der Entität Elemente zu erstellen und den Index zu diesem Zeitpunkt als Kategorie festzulegen.

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

Was damit passiert, bleiben zunächst die Elemente so, wie sie sind.

output

es['items'].df

Auf der anderen Seite wird die als Kategorie bezeichnete Entität in der neu angegebenen Kategoriespalte indiziert.

python

es['category'].df

Führen Sie dfs aus

Versuchen Sie, Anzahl, Summe und Mittelwert für agg_primitives anzugeben

python

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

Da die einzige Spalte, die aggregiert werden kann, items.price, COUNT (), category.MEAN () und category.SUM () sind, wird jeweils ein DataFrame mit 3 zusätzlichen Spalten erstellt.

4. Bei zwei Entitäten

Erstellen Sie einen 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

Erstellen Sie ein EntitySet

Ich werde die Entität wie zuvor hinzufügen

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

Erstellen Sie eine Beziehung, die die beiden Entitäten verbindet. Sie werden in der Spalte item_id von Elementen und in der Spalte item_id von Transaktionen zusammengeführt.

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

Führen Sie dfs aus

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

Wenn Sie nur die Spaltenüberschriften schreiben, sieht es wie folgt aus. Es führt sowohl die Aggregation als auch die Berechnung zwischen den Features durch.

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)']

Wie max_depth funktioniert

Mal sehen, was passiert, wenn wir max_depth mit dem obigen Code schrittweise erhöhen

max_depth=1

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

max_depth=1 → 2 erhöhen

['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=2 → 3 erhöhen

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

max_depth=Erhöhen Sie von 3 auf 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=4 → 5 erhöhen

[]

max_depth=Erhöhen Sie von 5 auf 6

[]

Es scheint, dass es sich um eine Spezifikation handelt, die agg_primitives, trans_primitives, agg_primitives, trans_primitives und Endes anwendet.

CUSTOM primitives

Es scheint, dass Sie auch Ihr eigenes Grundelement hinzufügen und berechnen können https://docs.featuretools.com/en/stable/getting_started/primitives.html#simple-custom-primitives

Zusammenfassung

Praktisch! !! !!