Tutorial: Bereitstellen und Abfragen eines Endpunkts für die Featurebereitstellung

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 und ihrer Lage (Breiten- und Längengrad) und einer Empfehlungs-App, die den aktuellen Abstand 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 Tables 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)	latitude	longitude
Nashville, 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. Erstellen einer Onlinetabelle

Eine Onlinetabelle ist eine schreibgeschützte Kopie einer Delta-Tabelle, die für den Onlinezugriff optimiert ist. Weitere Informationen finden Sie unter Verwenden von Onlinetabellen für die Echtzeit-Featurebereitstellung.

Zum Erstellen einer Onlinetabelle können Sie die Benutzeroberfläche Erstellen einer Onlinetabelle mithilfe der Benutzeroberfläche, die REST-API oder das Databricks-SDK verwenden, wie im folgenden Beispiel gezeigt:

from pprint import pprint
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import *
import mlflow

workspace = WorkspaceClient()

# Create an online table
feature_table_name = f"main.on_demand_demo.location_features"
online_table_name=f"main.on_demand_demo.location_features_online"

spec = OnlineTableSpec(
 primary_key_columns=["destination_id"],
 source_table_full_name = feature_table_name,
 run_triggered=OnlineTableSpecTriggeredSchedulingPolicy.from_dict({'triggered': 'true'}),
 perform_full_copy=True)

# ignore "already exists" error
try:
 online_table_pipeline = workspace.online_tables.create(name=online_table_name, spec=spec)
except Exception as e:
 if "already exists" in str(e):
   pass
 else:
   raise e

pprint(workspace.online_tables.get(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 im Artikel zum Erstellen einer Featurespezifikation.

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 nimmt die Funktion als Eingabe die aktuelle Position des Benutzers an (Breiten- und Längengrad). Da sich der Standort des Benutzers ständig ändert, muss er zur Rückschlusszeit als Kontextfeature für die 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 den Abstand 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:

Beispielnotebook für Feature Serving mit Onlinetabellen

Notebook abrufen

Weitere Informationen

Ausführliche Informationen zur Verwendung der Feature Engineering Python-API finden Sie in der Referenzdokumentation.