Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
In diesem Artikel wird schrittweise gezeigt, wie Sie einen Endpunkt für die Featurebereitstellung bereitstellen und abfragen. In diesem Artikel wird das Databricks-SDK verwendet. Einige Schritte können auch mit der REST-API oder der Databricks-Benutzeroberfläche abgeschlossen werden und enthalten Verweise auf die Dokumentation für diese Methoden.
In diesem Beispiel haben Sie eine Tabelle mit Städten mit ihren Standorten (Breiten- und Längengrad) und einer Empfehlungs-App, die die aktuelle Entfernung des Benutzers von diesen Städten berücksichtigt. Da sich der Standort des Benutzers ständig ändert, muss der Abstand zwischen dem Benutzer und jeder Stadt zum Zeitpunkt des Rückschlusses berechnet werden. In diesem Lernprogramm wird veranschaulicht, wie Sie diese Berechnungen mit geringer Latenz mithilfe von Databricks Online Feature Store und Databricks Feature Serving ausführen. Den vollständigen Beispielcode finden Sie im Beispielnotebook.
Schritt 1. Erstellen der Quelltabelle
Die Quelltabelle enthält vorausberechnete Featurewerte und kann eine beliebige Delta-Tabelle in Unity Catalog mit einem Primärschlüssel sein. In diesem Beispiel enthält die Tabelle eine Liste der Städte mit ihrem Breiten- und Längengrad. Der Primärschlüssel ist destination_id. Beispieldaten finden Sie weiter unten.
| Name | destination_id (pk) | Breite | Längengrad |
|---|---|---|---|
| Tennessee, Tennessee | 0 | 36.162663 | -86.7816 |
| Honolulu, Hawaii | 1 | 21.309885 | -157.85814 |
| Las Vegas, Nevada, USA | 2 | 36.171562 | -115.1391 |
| New York (New York, USA) | 3 | 40.712776 | -74.005974 |
Schritt 2. Erstellung des Online Feature Store
Ausführliche Informationen zu Databricks Online Feature Stores finden Sie unter Databricks Online Feature Stores.
from databricks.feature_engineering import FeatureEngineeringClient
fe = FeatureEngineeringClient()
feature_table_name = f"{catalog_name}.{schema_name}.location_features"
function_name = f"{catalog_name}.{schema_name}.distance"
# Create the feature table
fe.create_table(
name = feature_table_name,
primary_keys="destination_id",
df = destination_location_df,
description = "Destination location features."
)
# Enable Change Data Feed to enable CONTINOUS and TRIGGERED publish modes
spark.sql(f"ALTER TABLE {feature_table_name} SET TBLPROPERTIES (delta.enableChangeDataFeed = 'true')")
# Create an online store with specified capacity
online_store_name = f"{username}-online-store"
fe.create_online_store(
name=online_store_name,
capacity="CU_2" # Valid options: "CU_1", "CU_2", "CU_4", "CU_8"
)
# Wait until the state is AVAILABLE
online_store = fe.get_online_store(name=online_store_name)
online_store.state
# Publish the table
published_table = fe.publish_table(
online_store=online_store,
source_table_name=feature_table_name,
online_table_name=online_table_name
)
Schritt 3. Erstellen einer Funktion in Unity Catalog
In diesem Beispiel berechnet die Funktion den Abstand zwischen dem Ziel (dessen Position sich nicht ändert) und dem Benutzer (dessen Position sich häufig ändert und bis zum Zeitpunkt des Rückschlusses nicht bekannt ist).
# Define the function. This function calculates the distance between two locations.
function_name = f"main.on_demand_demo.distance"
spark.sql(f"""
CREATE OR REPLACE FUNCTION {function_name}(latitude DOUBLE, longitude DOUBLE, user_latitude DOUBLE, user_longitude DOUBLE)
RETURNS DOUBLE
LANGUAGE PYTHON AS
$$
import math
lat1 = math.radians(latitude)
lon1 = math.radians(longitude)
lat2 = math.radians(user_latitude)
lon2 = math.radians(user_longitude)
# Earth's radius in kilometers
radius = 6371
# Haversine formula
dlat = lat2 - lat1
dlon = lon2 - lon1
a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
distance = radius * c
return distance
$$""")
Schritt 4. Erstellen einer Featurespezifikation in Unity Catalog
Die Featurespezifikation gibt die Features, die der Endpunkt bereitstellt, und deren Nachschlageschlüssel an. Außerdem werden alle erforderlichen Funktionen angegeben, die auf die abgerufenen Features mit ihren Bindungen angewendet werden sollen. Weitere Informationen finden Sie unter Erstellen eines FeatureSpec.
from databricks.feature_engineering import FeatureLookup, FeatureFunction, FeatureEngineeringClient
fe = FeatureEngineeringClient()
features=[
FeatureLookup(
table_name=feature_table_name,
lookup_key="destination_id"
),
FeatureFunction(
udf_name=function_name,
output_name="distance",
input_bindings={
"latitude": "latitude",
"longitude": "longitude",
"user_latitude": "user_latitude",
"user_longitude": "user_longitude"
},
),
]
feature_spec_name = f"main.on_demand_demo.travel_spec"
# The following code ignores errors raised if a feature_spec with the specified name already exists.
try:
fe.create_feature_spec(name=feature_spec_name, features=features, exclude_columns=None)
except Exception as e:
if "already exists" in str(e):
pass
else:
raise e
Schritt 5. Erstellen eines Featurebereitstellungsendpunkts
Zum Erstellen eines Endpunkts für die Featurebereitstellung können Sie die Benutzeroberfläche Erstellen eines Endpunkts, die REST-API oder das Databricks-SDK verwenden, wie hier gezeigt.
Der Endpunkt für die Featurebereitstellung verwendet die feature_spec, die Sie in Schritt 4 erstellt haben, als Parameter.
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import EndpointCoreConfigInput, ServedEntityInput
# Create endpoint
endpoint_name = "fse-location"
try:
status = workspace.serving_endpoints.create_and_wait(
name=endpoint_name,
config = EndpointCoreConfigInput(
served_entities=[
ServedEntityInput(
entity_name=feature_spec_name,
scale_to_zero_enabled=True,
workload_size="Small"
)
]
)
)
print(status)
# Get the status of the endpoint
status = workspace.serving_endpoints.get(name=endpoint_name)
print(status)
Schritt 6. Abfragen des Featurebereitstellungsendpunkts
Wenn Sie den Endpunkt abfragen, geben Sie den Primärschlüssel und optional alle Kontextdaten an, die von der Funktion verwendet werden. In diesem Beispiel verwendet die Funktion die aktuelle Position des Benutzers (Breiten- und Längengrad). Da sich der Standort des Benutzers ständig ändert, muss er zur Inferenzzeit als Kontextmerkmal der Funktion bereitgestellt werden.
Sie können den Endpunkt auch mithilfe der Benutzeroberfläche Abfragen eines Endpunkts mithilfe der Benutzeroberfläche oder der REST-API abfragen.
Aus Gründen der Einfachheit berechnet dieses Beispiel nur den Abstand zu zwei Städten. Ein realistischeres Szenario kann die Entfernung des Benutzers von jedem Standort in der Featuretabelle berechnen, um zu bestimmen, welche Städte empfohlen werden sollen.
import mlflow.deployments
client = mlflow.deployments.get_deploy_client("databricks")
response = client.predict(
endpoint=endpoint_name,
inputs={
"dataframe_records": [
{"destination_id": 1, "user_latitude": 37, "user_longitude": -122},
{"destination_id": 2, "user_latitude": 37, "user_longitude": -122},
]
},
)
pprint(response)
Beispielnotebook
Eine vollständige Darstellung der Schritte finden Sie in diesem Notebook:
Feature Serving-Beispielnotizbuch mit Onlinespeicher
Weitere Informationen
Ausführliche Informationen zur Verwendung der Feature Engineering Python-API finden Sie in der Referenzdokumentation.