Tillhandahåll funktionsvyer

Du kan visa funktionsvyer online på två sätt:

  • Modellservering: Driftsätt en modell som har tränats på Feature Views. Endpointen slår automatiskt upp eller beräknar funktionsvärden, med hjälp av den härstamning som följdes när modellen loggades. Använd detta för att hantera modellförutsägelser.
  • Funktionsserver: Distribuera en FeatureSpec som refererar till funktionsvyer direkt, utan en modell. Endpointen returnerar de begärda funktionsutdata. Använd detta när ett program behöver funktionsvärden i stället för modellförutsägelser.

Båda metoderna stödjer förberäknade och on-demand-funktioner. Tabell- och strömbaserade leaf-funktioner måste ha onlinematerialiseringar som stöds. RequestSource Tillhandahåller värden från förfrågan och CustomUDF beräknar funktioner på begäran. För en CustomUDF med FeatureViewSource löser servering uppströmsberoenden och utvärderar automatiskt grafen över funktionsberoenden.

Registrera de önskade funktionerna och alla deras transitiva uppströmsfunktioner i Unity-katalogen. Materialisera endast de blad som stöds av tabeller och strömmar, inte de CustomUDF egenskaper som härleds eller beräknas vid begärandetillfället.

behörigheter

För att servera en feature måste principalen som skapar modellserveringsslutpunkten ha SELECT på Unity Catalog-tabellen som ligger till grund för den materialiserade featuren. Onlinesökningar läser direkt från den materialiserade tabellen, så SELECT på tabellnivå är det som ger serveringsåtkomst. Mer information om behörighetsbeskrivningen finns i SELECT.

Eftersom en materialiserad tabell kan innehålla mer än en funktion ger beviljande SELECT av den åtkomst till varje funktion i tabellen, inte bara den som du tänker hantera. Innan du beviljar åtkomst, säkerställ att alla objekt som delar tabellen kan delas med huvudmannen. För att begränsa exponeringen materialiserar du känsliga funktioner separat.

Om du vill ge den här åtkomsten utan att slå upp tabeller manuellt, använd FeatureEngineeringClient.grant_feature_serving_access. Med tanke på en modell eller funktionsspecifikation löser den varje funktion till sin onlinetabell, beviljar SELECT (tillsammans med USE CATALOG och USE SCHEMA) på dessa tabeller till de huvudkonton som du anger och returnerar en rapport för varje tabell och de ytterligare funktioner som beviljandet exponerar. Skicka dry_run=True för att förhandsgranska rapporten innan du beviljar den.

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()

# Preview the tables and the features each grant would expose.
report = fe.grant_feature_serving_access(
    grant_to=["serving-principal@example.com"],
    model_uri="models:/main.ecommerce.fraud_model/1",
    dry_run=True,
)
print(report)

# Grant SELECT on the resolved online tables.
fe.grant_feature_serving_access(
    grant_to=["serving-principal@example.com"],
    model_uri="models:/main.ecommerce.fraud_model/1",
)

Distribuera en modell som betjänar slutpunkt

Använd en befintlig modell som betjänar slutpunkten eller använd Databricks SDK för att skapa en ny. Modellen måste vara registrerad i Unity Catalog.

Om a CustomUDF använder en användardefinierad funktion (UDF) som importerar Python-paket, skicka dem explicit genom extra_pip_requirements när du anropar log_model. Se Anpassade UDF-beroenden.

Följande kod visar hur du skapar en ny modell som betjänar slutpunkten. Mer information finns i Skapa anpassade modellserverslutpunkter.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import EndpointCoreConfigInput, ServedEntityInput

w = WorkspaceClient()

endpoint_name = "fraud-detection-endpoint"
model_name = "main.ecommerce.fraud_model"

w.serving_endpoints.create(
    name=endpoint_name,
    config=EndpointCoreConfigInput(
        name=endpoint_name,
        served_entities=[
            ServedEntityInput(
                entity_name=model_name,
                entity_version=1,
                max_provisioned_concurrency=4,
                min_provisioned_concurrency=0,
            )
        ],
    ),
)

Fråga slutpunkten

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

response = w.serving_endpoints.query(
    name="fraud-detection-endpoint",
    dataframe_records=[
        {"user_id": "user_123", "transaction_time": "2026-03-01T12:00:00"},
    ],
)

Fråga slutpunkten med RequestSource-funktioner

Om modellen har tränats med RequestSource funktioner måste nyttolasten för begäran även innehålla alla RequestSource kolumner. Dessa kolumner lades till i MLflow-modellsignaturen under log_model, så slutpunktens API-schema återspeglar de obligatoriska fälten för begäran.

response = w.serving_endpoints.query(
    name="fraud-detection-endpoint",
    dataframe_records=[
        {
            "user_id": "user_123",
            "transaction_time": "2026-03-01T12:00:00",
            "transaction_amount": 275.30,  # RequestSource column
            "vendor_id": "v_42",           # RequestSource column (also used as entity key)
        },
    ],
)

Entitetsnycklar används för att leta upp tabellbaserade funktioner från onlinebutiken. En ColumnSelection funktion kan skicka ett RequestSource värde vidare till modellen. En CustomUDF funktion transformerar sina begäransökningsindata innan modellen använder resultatet.

Du kan också använda curl:

curl -X POST "https://<workspace>.cloud.databricks.com/serving-endpoints/<endpoint>/invocations" \
  -H "Authorization: Bearer $DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "dataframe_records": [
      {
        "user_id": "user_123",
        "transaction_time": "2026-03-01T12:00:00",
        "transaction_amount": 275.30,
        "vendor_id": "v_42"
      }
    ]
  }'

Hantera funktioner med en FeatureSpec

Om du vill hantera funktionsvyer utan en modell skapar du en FeatureSpec som refererar till funktionerna och distribuerar den till en funktionsserverslutpunkt. Endpointen returnerar endast de funktionsutdata som efterfrågats i specifikationen. Den beräknar automatiskt mellanliggande värden utan att returnera dem om du inte också begär dessa funktioner.

Registrera alla funktioner i Unity-katalogen och skapa stödda onlinematerialiseringar för tabell- och strömbackade blad innan du skapar endpointen.

Note

En FeatureSpec som innehåller funktionsvyer får inte heller innehålla FeatureLookup eller FeatureFunction definitioner. Funktionsvyer kan inte blandas med dessa definitioner i samma FeatureSpec.

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities.feature_serving_endpoint import (
    EndpointCoreConfig,
    ServedEntity,
)

fe = FeatureEngineeringClient()

# 1. Retrieve a registered Feature View
agg_feature = fe.get_feature(full_name="main.ecommerce.amount_sum_sliding_7d_1d")

# 2. Create a FeatureSpec that includes the Feature View
feature_spec_name = "main.ecommerce.transaction_feature_spec"
fe.create_feature_spec(name=feature_spec_name, features=[agg_feature])

# 3. Deploy a Feature Serving endpoint backed by the FeatureSpec
fe.create_feature_serving_endpoint(
    name="transaction-features",
    config=EndpointCoreConfig(
        served_entities=ServedEntity(
            feature_spec_name=feature_spec_name,
            workload_size="Small",
            scale_to_zero_enabled=True,
        )
    ),
)

Gör en förfrågan till slutpunkten med de entitetsnycklar som används för att slå upp de materialiserade funktionerna:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

response = w.serving_endpoints.query(
    name="transaction-features",
    dataframe_records=[{"user_id": "user_123"}],
)

För mer om Feature Serving-endpoints, se Serve feature tables.

Tillhandahåll CustomUDF-funktioner och deras beroenden

Detta exempel är avsett för funktionerna för transaktioner och marginaler som definieras i exemplen CustomUDF och FeatureViewSource. Använd databricks-feature-engineering version 0.18.0 eller högre för dessa Feature Views-API:er.

  • log_transaction_amount gäller main.ecommerce.log_amount_udf för förfrågans transaction_amount värde med NumPy.
  • margin använder FeatureViewSource för att beräkna en marginal från revenue_sum_7d och cost_sum_7d. Dessa upstream-funktioner använder customer_id som sin entitetsnyckel och event_time som sin tidsseriekolumn.

Registrera både utdatafunktioner och alla föregående funktioner innan du skapar specifikationen. I det här exemplet materialiseras endast bladen revenue_sum_7d och cost_sum_7d online. Serveringen slår upp deras värden och beräknar margin för varje begäran.

Hämta de registrerade Feature objekten och skicka dem till create_feature_spec. Deklarera NumPy för online-exekvering även om det redan finns med i UDF:s klausul:ENVIRONMENT

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()
log_transaction_amount = fe.get_feature(
    full_name="main.ecommerce.log_transaction_amount"
)
margin = fe.get_feature(full_name="main.ecommerce.margin")

fe.create_feature_spec(
    name="main.ecommerce.derived_transaction_features",
    features=[log_transaction_amount, margin],
    extra_pip_requirements=["numpy==1.26.4"],
)

Följ stegen för slutpunktsskapandet ovan med feature_spec_name="main.ecommerce.derived_transaction_features" och ett ändpunktsnamn såsom derived-transaction-features. När ändpunkten är klar anger du uppslagsnyckeln och värdet vid begärandetillfället:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="derived-transaction-features",
    dataframe_records=[
        {"customer_id": "customer_123", "transaction_amount": 99.0},
    ],
)

Svaret innehåller endast de begärda log_transaction_amount och margin utfallande värdena, inte mellanliggande intäkts- och kostnadsvärden. För beroendeformat, hjulbehörigheter och felsökning av installationer, se Add Python dependencies.

  • Uppdaterades senast