Distribuera och fråga en funktion som betjänar slutpunkten

Artikel
08/14/2024

Den här artikeln visar hur du distribuerar och frågar en funktion som betjänar slutpunkten i en stegvis process. Den här artikeln använder Databricks SDK. Vissa steg kan också slutföras med hjälp av REST-API:et eller Databricks-användargränssnittet och innehålla referenser till dokumentationen för dessa metoder.

I det här exemplet har du en tabell med städer med deras platser (latitud och longitud) och en rekommenderande app som tar hänsyn till användarens aktuella avstånd från dessa städer. Eftersom användarens plats ändras konstant måste avståndet mellan användaren och varje stad beräknas vid tidpunkten för slutsatsdragningen. Den här självstudien visar hur du utför dessa beräkningar med låg svarstid med databricks onlinetabeller och Databricks-funktionsservering. Den fullständiga uppsättningen med exempelkod finns i exempelanteckningsboken.

Steg 1. Skapa källtabellen

Källtabellen innehåller förberäknade funktionsvärden och kan vara valfri Delta-tabell i Unity Catalog med en primärnyckel. I det här exemplet innehåller tabellen en lista över städer med deras latitud och longitud. Den primära nyckeln är destination_id. Exempeldata visas nedan.

name	destination_id (pk)	latitude	longitud
Nashville, Tennessee	0	36.162663	-86.7816
Honolulu, Hawaii	1	21.309885	-157.85814
Las Vegas, Nevada	2	36.171562	-115.1391
New York, New York	3	40.712776	-74.005974

Steg 2. Skapa en onlinetabell

En onlinetabell är en skrivskyddad kopia av en deltatabell som är optimerad för onlineåtkomst. Mer information finns i Använda onlinetabeller för funktionsservering i realtid.

Om du vill skapa en onlinetabell kan du använda användargränssnittet Skapa en onlinetabell med hjälp av användargränssnittet, REST-API:et eller Databricks SDK, som i följande exempel:

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

Steg 3. Skapa en funktion i Unity Catalog

I det här exemplet beräknar funktionen avståndet mellan målet (vars plats inte ändras) och användaren (vars plats ändras ofta och inte är känd förrän inferensen).

# 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
$$""")

Steg 4. Skapa en funktionsspecifikation i Unity Catalog

Funktionsspecifikationen anger de funktioner som slutpunkten fungerar och deras uppslagsnycklar. Den anger även alla nödvändiga funktioner som ska tillämpas på de hämtade funktionerna med sina bindningar. Mer information finns i Skapa en 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

Steg 5. Skapa en funktionsserverslutpunkt

Om du vill skapa en funktionsserverslutpunkt kan du använda användargränssnittet Skapa en slutpunkt, REST-API:et eller Databricks SDK som visas här.

Den funktion som betjänar slutpunkten tar den feature_spec som du skapade i steg 4 som en 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)

Steg 6. Fråga efter funktionsserverns slutpunkt

När du kör frågor mot slutpunkten anger du den primära nyckeln och eventuellt eventuella kontextdata som funktionen använder. I det här exemplet tar funktionen som indata användarens aktuella plats (latitud och longitud). Eftersom användarens plats ständigt ändras måste den tillhandahållas till funktionen vid slutsatsdragningstid som en kontextfunktion.

Du kan också fråga slutpunkten med hjälp av användargränssnittet Fråga en slutpunkt med hjälp av användargränssnittet eller REST-API:et.

För enkelhetens skull beräknar det här exemplet bara avståndet till två städer. Ett mer realistiskt scenario kan beräkna användarens avstånd från varje plats i funktionstabellen för att avgöra vilka städer som ska rekommenderas.

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)

Exempel på notebook-fil

Se den här notebook-filen för en fullständig bild av stegen:

Exempelanteckningsbok för funktionsserver med onlinetabeller

Hämta notebook-fil

Ytterligare information

Mer information om hur du använder python-API:et för funktionsframställning finns i referensdokumentationen.

Dela via