Arbeiten mit Featuretabellen im Unity-Katalog

Auf dieser Seite wird beschrieben, wie Sie Featuretabellen in Unity Catalog erstellen und mit ihnen arbeiten.

Diese Seite gilt nur für Arbeitsbereiche, die für Unity Catalog aktiviert sind. Wenn Ihr Arbeitsbereich nicht für Unity Catalog aktiviert ist, lesen Sie Arbeiten mit Featuretabellen in Workspace Feature Store (Legacy).

Ausführliche Informationen zu den Befehlen und Parametern, die in den Beispielen auf dieser Seite verwendet werden, finden Sie in der Referenz zur Python-API für Feature Engineering.

Anforderungen

Feature Engineering in Unity Catalog erfordert Databricks Runtime 13.2 oder höher. Darüber hinaus muss der Unity Catalog-Metastore über die Version 1.0 des Berechtigungsmodells verfügen.

Installieren von Feature Engineering im Unity Catalog-Python-Client

Für das Feature Engineering in Unity Catalog steht ein Python-Client bereit: FeatureEngineeringClient. Die Klasse ist unter PyPI mit dem Paket databricks-feature-engineering verfügbar und ist in Databricks Runtime 13.3 LTS ML und höher vorinstalliert. Wenn Sie eine Nicht-ML-Version von Databricks Runtime verwenden, müssen Sie den Client manuell installieren. Verwenden Sie die Kompatibilitätsmatrix, um die richtige Version für Ihre Databricks Runtime-Version zu ermitteln.

%pip install databricks-feature-engineering

dbutils.library.restartPython()

Erstellen eines Katalogs und eines Schemas für Featuretabellen in Unity Catalog

Sie müssen einen neuen Katalog erstellen oder einen vorhandenen für Featuretabellen verwenden.

Um einen neuen Katalog zu erstellen, müssen Sie über die CREATE CATALOG-Berechtigung für den Metastore verfügen.

CREATE CATALOG IF NOT EXISTS <catalog-name>

Um einen vorhandenen Katalog verwenden zu können, müssen Sie über die USE CATALOG-Berechtigung für ihn verfügen.

USE CATALOG <catalog-name>

Featuretabellen in Unity Catalog müssen in einem Schema gespeichert werden. Um ein neues Schema im Katalog zu erstellen, müssen Sie über die CREATE SCHEMA-Berechtigung für ihn verfügen.

CREATE SCHEMA IF NOT EXISTS <schema-name>

Erstellen einer Featuretabelle in Unity Catalog

Featuretabellen im Unity Catalog sind Delta-Tabellen. Eine Featuretabelle muss einen Primärschlüssel aufweisen. Auf Featuretabellen, wie andere Datenressourcen im Unity Catalog, wird mithilfe eines Namespace mit drei Ebenen zugegriffen: <catalog-name>.<schema-name>.<table-name>

Sie können Databricks SQL, Python FeatureEngineeringClientoder Lakeflow Spark Declarative Pipelines verwenden, um Featuretabellen im Unity-Katalog zu erstellen.

Databricks SQL

Sie können jede Delta-Tabelle mit einer Primärschlüsseleinschränkung als Featuretabelle verwenden. Der folgende Code veranschaulicht das Erstellen einer Tabelle mit einem Primärschlüssel:

CREATE TABLE ml.recommender_system.customer_features (
  customer_id int NOT NULL,
  feat1 long,
  feat2 varchar(100),
  CONSTRAINT customer_features_pk PRIMARY KEY (customer_id)
);

Um eine Featuretabelle für Zeitreihen zu erstellen, fügen Sie eine Zeitspalte als Primärschlüsselspalte hinzu, und geben Sie das TIMESERIES Schlüsselwort an. Das TIMESERIES Schlüsselwort erfordert Databricks Runtime 13.3 LTS oder höher.

CREATE TABLE ml.recommender_system.customer_features (
  customer_id int NOT NULL,
  ts timestamp NOT NULL,
  feat1 long,
  feat2 varchar(100),
  CONSTRAINT customer_features_pk PRIMARY KEY (customer_id, ts TIMESERIES)
);

Nach dem Erstellen der Tabelle können Sie Daten wie bei anderen Delta-Tabellen schreiben und diese Tabelle als Featuretabelle verwenden.

Python

Ausführliche Informationen zu den Befehlen und Parametern, die in den folgenden Beispielen verwendet werden, finden Sie in der Referenz zur Feature Engineering-Python-API.

1. Schreiben Sie die Python-Funktionen, um die Features zu berechnen. Jede Funktion sollte einen Apache Spark-Datenrahmen mit einem eindeutigen Primärschlüssel ausgeben. Der Primärschlüssel kann aus einer oder mehreren Spalten bestehen.
2. Erstellen Sie eine Featuretabelle, indem Sie einen FeatureEngineeringClient instanziieren und create_table verwenden.
3. Füllen Sie die Featuretabelle mithilfe von write_table auf.

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()

# Prepare feature DataFrame
def compute_customer_features(data):
  ''' Feature computation code returns a DataFrame with 'customer_id' as primary key'''
  pass

customer_features_df = compute_customer_features(df)

# Create feature table with `customer_id` as the primary key.
# Take schema from DataFrame output by compute_customer_features
customer_feature_table = fe.create_table(
  name='ml.recommender_system.customer_features',
  primary_keys='customer_id',
  schema=customer_features_df.schema,
  description='Customer features'
)

# An alternative is to use `create_table` and specify the `df` argument.
# This code automatically saves the features to the underlying Delta table.

# customer_feature_table = fe.create_table(
#  ...
#  df=customer_features_df,
#  ...
# )

# To use a composite primary key, pass all primary key columns in the create_table call

# customer_feature_table = fe.create_table(
#   ...
#   primary_keys=['customer_id', 'date'],
#   ...
# )

# To create a time series table, set the timeseries_columns argument

# customer_feature_table = fe.create_table(
#   ...
#   primary_keys=['customer_id', 'date'],
#   timeseries_columns='date',
#   ...
# )

Erstellen einer Featuretabelle im Unity-Katalog mit Lakeflow Spark Declarative Pipelines

Jede Tabelle, die aus Lakeflow Spark Declarative Pipelines veröffentlicht wird, die eine Primärschlüsseleinschränkung enthält, kann als Featuretabelle verwendet werden. Um eine Tabelle in einer Pipeline mit einem Primärschlüssel zu erstellen, können Sie entweder Databricks SQL oder die Programmierschnittstelle für Lakeflow Spark Declarative Pipelines Python verwenden.

Verwenden Sie die folgende Syntax, um eine Tabelle in einer Pipeline mit einem Primärschlüssel zu erstellen:

Databricks SQL

CREATE MATERIALIZED VIEW customer_features (
  customer_id int NOT NULL,
  feat1 long,
  feat2 varchar(100),
  CONSTRAINT customer_features_pk PRIMARY KEY (customer_id)
) AS SELECT * FROM ...;

Python

from pyspark import pipelines as dp

@dp.materialized_view(
  schema="""
          customer_id int NOT NULL,
          feat1 long,
          feat2 varchar(100),
          CONSTRAINT customer_features_pk PRIMARY KEY (customer_id)
    """)
def customer_features():
  return ...

Um eine Featuretabelle für Zeitreihen zu erstellen, fügen Sie eine Zeitspalte als Primärschlüsselspalte hinzu, und geben Sie das TIMESERIES Schlüsselwort an.

Databricks SQL

CREATE MATERIALIZED VIEW customer_features (
  customer_id int NOT NULL,
  ts timestamp NOT NULL,
  feat1 long,
  feat2 varchar(100),
  CONSTRAINT customer_features_pk PRIMARY KEY (customer_id, ts TIMESERIES)
) AS SELECT * FROM ...;

Python

from pyspark import pipelines as dp

@dp.materialized_view(
  schema="""
    customer_id int NOT NULL,
    ts timestamp NOT NULL,
    feat1 long,
    feat2 varchar(100),
    CONSTRAINT customer_features_pk PRIMARY KEY (customer_id, ts TIMESERIES)
    """)
def customer_features():
  return ...

Nachdem die Tabelle erstellt wurde, können Sie Daten wie andere Lakeflow Spark Declarative Pipelines-Datasets in sie schreiben und als Featuretabelle verwenden.

Verwenden einer vorhandenen Delta-Tabelle als Featuretabelle in Unity Catalog

Jede Delta-Tabelle in Unity Catalog mit einem Primärschlüssel kann eine Featuretabelle in Unity Catalog sein, und Sie können die Benutzeroberfläche und API für Features mit der Tabelle verwenden.

Wenn eine vorhandene Delta-Tabelle keine Primärschlüsseleinschränkung hat, können Sie wie folgt eine erstellen:

1. Legen Sie die Primärschlüsselspalten auf NOT NULL fest. Führen Sie für jede Primärschlüsselspalte Folgendes aus:

   ALTER TABLE <full_table_name> ALTER COLUMN <pk_col_name> SET NOT NULL
   

2. Bearbeiten Sie die Tabelle, um die Primärschlüsseleinschränkung hinzuzufügen:

   ALTER TABLE <full_table_name> ADD CONSTRAINT <pk_name> PRIMARY KEY(pk_col1, pk_col2, ...)
   

   pk_name ist der Name der Primärschlüsseleinschränkung. Gemäß der Konvention können Sie den Tabellennamen (ohne Schema und Katalog) mit einem _pk-Suffix verwenden. Beispielsweise würde für eine Tabelle mit dem Namen "ml.recommender_system.customer_features" der Name der Primärschlüsseleinschränkung customer_features_pk lauten.

   Um die Tabelle zu einer Featuretabelle für Zeitreihen zu machen, geben Sie das TIMESERIES Schlüsselwort in einer der Primärschlüsselspalten wie folgt an:

   ALTER TABLE <full_table_name> ADD CONSTRAINT <pk_name> PRIMARY KEY(pk_col1 TIMESERIES, pk_col2, ...)
   

   Nachdem Sie der Tabelle die Primärschlüsseleinschränkung hinzugefügt haben, wird die Tabelle auf der Benutzeroberfläche für Features angezeigt, und Sie können die Tabelle als Featuretabelle verwenden.

Verwenden Sie eine Streamingtabelle oder materialisierte Ansicht, die von Lakeflow Spark Declarative Pipelines als Feature-Tabelle erstellt ist

Jede Streamingtabelle oder materialisierte Sicht in Unity Catalog mit einem Primärschlüssel kann eine Featuretabelle in Unity Catalog sein, und Sie können die Benutzeroberfläche und API für Features mit der Tabelle verwenden.

Um Primärschlüssel für eine vorhandene Streamingtabelle oder materialisierte Sicht festzulegen, aktualisieren Sie das Schema der Streamingtabelle oder materialisierten Sicht im Notebook, mit dem das Objekt verwaltet wird. Aktualisieren Sie danach die Tabelle, um das Unity Catalog-Objekt zu aktualisieren.

Die Syntax zum Hinzufügen eines Primärschlüssels zu einer materialisierten Ansicht ist wie folgt:

Databricks SQL

CREATE OR REFRESH MATERIALIZED VIEW existing_live_table(
  id int NOT NULL PRIMARY KEY,
  ...
) AS SELECT ...

Python

from pyspark import pipelines as dp

@dp.materialized_view(
  schema="""
    id int NOT NULL PRIMARY KEY,
    ...
    """
)
def existing_live_table():
  return ...

Verwenden einer vorhandenen Ansicht im Unity-Katalog als Featuretabelle

Um eine Ansicht als Featuretabelle zu verwenden, müssen Sie databricks-feature-engineering Version 0.7.0 oder höher verwenden, die in Databricks Runtime 16.0 ML integriert ist.

Eine einfache SELECT Ansicht im Unity-Katalog kann eine Featuretabelle im Unity-Katalog sein, und Sie können die Features-API mit der Tabelle verwenden.

Hier ist ein Beispiel für eine einfache SELECT Ansicht, die als Featuretabelle verwendet werden kann:

CREATE OR REPLACE VIEW ml.recommender_system.content_recommendation_subset AS
SELECT
    user_id,
    content_id,
    user_age,
    user_gender,
    content_genre,
    content_release_year,
    user_content_watch_duration,
    user_content_like_dislike_ratio
FROM
    ml.recommender_system.content_recommendations_features
WHERE
    user_age BETWEEN 18 AND 35
    AND content_genre IN ('Drama', 'Comedy', 'Action')
    AND content_release_year >= 2010
    AND user_content_watch_duration > 60;

Featuretabellen, die auf Ansichten basieren, können für Offlinemodellschulungen und -auswertungen verwendet werden. Sie können nicht in Online-Stores veröffentlicht werden. Features aus diesen Tabellen und Modellen, die auf diesen Features basieren, können nicht bereitgestellt werden.

Aktualisieren einer Featuretabelle in Unity Catalog

Sie können eine Merkmaltabelle im Unity-Katalog aktualisieren, indem Sie neue Merkmale hinzufügen oder bestimmte Zeilen basierend auf dem Primärschlüssel ändern.

Die folgenden Metadaten der Featuretabelle sollten nicht aktualisiert werden.

• Der Primärschlüssel.
• Der Partitionsschlüssel.
• Der Name oder Datentyp eines vorhandenen Features.

Wenn Sie diese Metadaten ändern, werden Downstreampipelines unterbrochen, die Features zum Trainieren und Bereitstellen von Modellen verwenden.

Hinzufügen neuer Features zu einer vorhandenen Featuretabelle in Unity Catalog

Sie können einer vorhandenen Featuretabelle auf zwei Arten neue Features hinzufügen:

• Aktualisieren Sie die vorhandene Featureberechnungsfunktion, und führen Sie write_table mit dem zurückgegebenen Datenrahmen aus. Dadurch wird das Featuretabellenschema aktualisiert, und es werden neue Featurewerte basierend auf dem Primärschlüssel zusammengeführt.
• Erstellen Sie eine neue Featureberechnungsfunktion, um die neuen Featurewerte zu berechnen. Der von dieser neuen Berechnungsfunktion zurückgegebene DataFrame muss die primären Schlüssel und Partitionsschlüssel der Featuretabellen (sofern definiert) enthalten. Führen Sie write_table mit dem DataFrame aus, um die neuen Features unter Verwendung desselben Primärschlüssels in die vorhandene Featuretabelle zu schreiben.

Aktualisieren nur bestimmter Zeilen in einer Featuretabelle

Verwenden Sie mode = "merge" in write_table. Zeilen, deren Primärschlüssel nicht im Datenrahmen existiert, der im write_table-Aufruf gesendet wurde, bleiben unverändert.

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()
fe.write_table(
  name='ml.recommender_system.customer_features',
  df = customer_features_df,
  mode = 'merge'
)

Einen Auftrag zum Aktualisieren einer Funktionstabelle planen

Für Databricks wird empfohlen, einen Auftrag zu erstellen, der ein Notebook zum regelmäßigen Aktualisieren Ihrer Featuretabelle (z. B. täglich) ausführt, um sicherzustellen, dass Features in Featuretabellen immer über die neuesten Werte verfügen. Wenn Sie bereits einen nicht geplanten Auftrag erstellt haben, können Sie ihn in einen geplanten Auftrag konvertieren, um sicherzustellen, dass die Featurewerte immer auf dem neuesten Stand sind. Siehe Lakeflow Jobs.

Code zum Aktualisieren einer Featuretabelle verwendet mode='merge', wie im folgenden Beispiel gezeigt.

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()

customer_features_df = compute_customer_features(data)

fe.write_table(
  df=customer_features_df,
  name='ml.recommender_system.customer_features',
  mode='merge'
)

Speichern früherer Werte täglicher Features

Definieren Sie eine Featuretabelle mit einem zusammengesetzten Primärschlüssel. Schließen Sie das Datum in den Primärschlüssel ein. Für eine Featuretabelle customer_features können Sie beispielsweise einen zusammengesetzten Primärschlüssel (date, customer_id) und einen Partitionsschlüssel date für effiziente Lesevorgänge verwenden.

Databricks empfiehlt, für effiziente Lesvorgänge das flüssige Clustering für die Tabelle zu aktivieren. Wenn Sie das flüssige Clustering nicht verwenden, legen Sie die Datumsspalte als Partitionsschlüssel fest, um die Leseleistung zu verbessern.

Databricks SQL

CREATE TABLE ml.recommender_system.customer_features (
  customer_id int NOT NULL,
  `date` date NOT NULL,
  feat1 long,
  feat2 varchar(100),
  CONSTRAINT customer_features_pk PRIMARY KEY (`date`, customer_id)
)
-- If you are not using liquid clustering, uncomment the following line.
-- PARTITIONED BY (`date`)
COMMENT "Customer features";

Python

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()
fe.create_table(
  name='ml.recommender_system.customer_features',
  primary_keys=['date', 'customer_id'],
  # If you are not using liquid clustering, uncomment the following line.
  # partition_columns=['date'],
  schema=customer_features_df.schema,
  description='Customer features'
)

Danach können Sie Code erstellen, der aus der Feature-Tabelle liest und dabei date auf den gewünschten Zeitraum filtert.

Sie können außerdem eine Featuretabelle für Zeitreihen erstellen, die zeitpunktbezogene Lookups ermöglicht, wenn Sie create_training_set oder score_batch verwenden. Weitere Informationen finden Sie unter Erstellen einer Featuretabelle in Unity Catalog.

Richten Sie einen regelmäßig geplanten Auftrag zum Schreiben von Features ein, oder streamen Sie neue Featurewerte in die Featuretabelle, um die Featuretabelle auf dem neuesten Stand zu halten.

Erstellen Sie eine Pipeline zur Berechnung von Streaming-Funktionen, um Features zu aktualisieren.

Übergeben Sie ein Streaming-DataFrame als Argument an write_table, um eine Pipeline für die Berechnung von Streamingfunktionen zu erstellen. Diese Methode gibt ein StreamingQuery-Objekt zurück.

def compute_additional_customer_features(data):
  ''' Returns Streaming DataFrame
  '''
  pass

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()

customer_transactions = spark.readStream.table("prod.events.customer_transactions")
stream_df = compute_additional_customer_features(customer_transactions)

fe.write_table(
  df=stream_df,
  name='ml.recommender_system.customer_features',
  mode='merge'
)

Lesen aus einer Featuretabelle in Unity Catalog

Verwenden Sie read_table, um Featurewerte zu lesen.

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()
customer_features_df = fe.read_table(
  name='ml.recommender_system.customer_features',
)

Suchen und Durchsuchen von Featuretabellen in Unity Catalog

Verwenden Sie die Features-Benutzeroberfläche, um in Unity Catalog nach Featuretabellen zu suchen oder diese zu durchsuchen.

1. Klicken Sie in der Randleiste auf Features, um die Featurebenutzeroberfläche anzuzeigen.

2. Wählen Sie mit dem Katalogauswahlwerkzeug einen Katalog aus, um alle verfügbaren Featuretabellen darin anzuzeigen. Geben Sie im Suchfeld ganz oder teilweise den Namen einer Featuretabelle, eines Features oder eines Kommentars ein. Sie können auch den Schlüssel oder Wert eines Tags ganz oder teilweise eingeben. Bei Suchtext wird die Groß-/Kleinschreibung nicht beachtet.

   

Abrufen von Metadaten aus Featuretabellen in Unity Catalog

Verwenden Sie get_table, um Featuretabellenmetadaten abzurufen.

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()
ft = fe.get_table(name="ml.recommender_system.user_feature_table")
print(ft.features)

Verwenden von Tags mit Featuretabellen und Features in Unity Catalog

Sie können Tags verwenden, bei denen es sich um einfache Schlüssel-Wert-Paare handelt, um Ihre Featuretabellen und Features zu kategorisieren und zu verwalten.

Für Featuretabellen können Sie Tags mithilfe des Katalog-Explorers, SQL-Anweisungen in einem Notebook oder SQL-Abfrage-Editor oder der Feature Engineering Python-API erstellen, bearbeiten und löschen.

Für Features können Sie Tags mithilfe des Katalog-Explorers, SQL-Anweisungen in einem Notebook oder SQL-Abfrage-Editor erstellen, bearbeiten und löschen.

Siehe Anwenden von Tags auf sicherungsfähige Unity-Katalog-Objekte und Python-API.

Das folgende Beispiel zeigt, wie Sie die Python-API für das Feature Engineering zum Erstellen, Aktualisieren und Löschen von Featuretabellentags verwenden.

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()

# Create feature table with tags
customer_feature_table = fe.create_table(
  # ...
  tags={"tag_key_1": "tag_value_1", "tag_key_2": "tag_value_2", ...},
  # ...
)

# Upsert a tag
fe.set_feature_table_tag(name="customer_feature_table", key="tag_key_1", value="new_key_value")

# Delete a tag
fe.delete_feature_table_tag(name="customer_feature_table", key="tag_key_2")

Löschen einer Featuretabelle in Unity Catalog

Sie können eine Featuretabelle in Unity Catalog löschen, indem Sie die Delta-Tabelle in Unity Catalog mithilfe des Katalog-Explorers oder mithilfe der Python-API für das Feature Engineering direkt löschen.

Sie können Databricks SQL verwenden oder FeatureEngineeringClient.drop_table, um eine Featuretabelle in Unity Catalog zu löschen:

Databricks SQL

DROP TABLE ml.recommender_system.customer_features;

Python

from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()
fe.drop_table(
  name='ml.recommender_system.customer_features'
)

Teilen Sie eine Feature-Tabelle im Unity-Katalog zwischen Arbeitsbereichen oder Konten

Eine Funktionstabelle in Unity Catalog ist für alle Arbeitsbereiche zugänglich, die dem Unity Catalog Metastore der Tabelle zugewiesen sind.

Über Delta Sharing können Sie eine Featuretabelle für Arbeitsbereiche freigeben, die nicht demselben Unity-Katalog-Metastore zugewiesen sind.

Beispielnotebooks

Das einfache Notizbuch zeigt, wie Sie eine Featuretabelle erstellen, es zum Trainieren eines Modells verwenden und die Batchbewertung mithilfe der automatischen Featuresuche ausführen. Außerdem wird die Feature engineering-Benutzeroberfläche angezeigt, mit der Sie nach Features suchen und verstehen können, wie Features erstellt und verwendet werden.

Grundlegendes zum Feature Engineering im Beispielnotebook für Unity Catalog

Notebook abrufen

Das Taxibeispiel-Notizbuch veranschaulicht den Prozess des Erstellens von Features, des Aktualisierens von Features und deren Verwendung für das Modelltraining und die Batch-Inferenz.

Notebook mit Feature Engineering-Taxibeispiel in Unity Catalog

Notebook abrufen