Featureweergaven aanbieden

U kunt functieweergaven op twee manieren online aanbieden:

• Modelbediening: Implementeer een model dat is getraind op Feature Views. Het eindpunt zoekt featurewaarden automatisch op of berekent deze met behulp van de herkomstgegevens die zijn vastgelegd toen het model werd geregistreerd. Gebruik dit om modelvoorspellingen te leveren.
• Functieweergave: Implementeer een FeatureSpec functie die rechtstreeks verwijst naar functieweergaven, zonder een model. Het eindpunt geeft de gevraagde feature-uitvoer terug. Gebruik deze optie wanneer een toepassing functiewaarden nodig heeft in plaats van modelvoorspellingen.

Beide benaderingen ondersteunen vooraf berekende en on-demand functies. Leaf-features die door tabellen en streams worden ondersteund, moeten ondersteunde online materialisaties hebben. RequestSource levert waarden uit het verzoek en CustomUDF berekent functies op aanvraag. Voor een CustomUDF met FeatureViewSource, lost serving upstream-afhankelijkheden op en evalueert het automatisch de feature-afhankelijkheidsgrafiek.

Registreer de gevraagde functies en al hun transitieve upstream-functies in de Unity-catalogus. Materialiseer alleen de door tabellen en streams ondersteunde leaf-knooppunten, niet de CustomUDF features die tijdens de aanvraag worden bepaald of afgeleid.

Permissions

Om een feature beschikbaar te stellen, moet de principal die het modelserving-eindpunt maakt, beschikken over SELECT voor de Unity Catalog-tabel waaraan de gematerialiseerde feature ten grondslag ligt. Onlinezoekacties worden rechtstreeks uit de gerealiseerde tabel gelezen, dus op tabelniveau SELECT wordt toegang verleend. Zie SELECT voor de beschrijving van de bevoegdheid.

Omdat een gematerialiseerde tabel meer dan één feature kan bevatten, geeft het verlenen van SELECT erop toegang tot elke feature in die tabel, niet alleen tot de feature die u wilt aanbieden. Voordat u toegang verleent, moet u controleren of elke functie die de tabel deelt, kan worden gedeeld met de principal. Als u de blootstelling wilt beperken, materialiseert u gevoelige functies afzonderlijk.

Als u deze toegang wilt verlenen zonder tabellen handmatig op te lossen, gebruikt u FeatureEngineeringClient.grant_feature_serving_access. Op basis van een model- of featurespecificatie wordt voor elke feature de bijbehorende onlinetabel bepaald, wordt SELECT (samen met USE CATALOG en USE SCHEMA) op die tabellen verleend aan de door u opgegeven principals, en wordt een rapport geretourneerd van elke tabel en de aanvullende features waartoe de machtiging toegang geeft. Geef dry_run=True door om het rapport te bekijken voordat u toegang verleent.

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

Een eindpunt voor het leveren van een model implementeren

Gebruik een bestaand model voor eindpunten of gebruik de Databricks SDK om een nieuw model te maken. Het model moet zijn geregistreerd in Unity Catalog.

Als a CustomUDF een door de gebruiker gedefinieerde functie (UDF) gebruikt die Python-pakketten importeert, laat ze dan expliciet doorlopen extra_pip_requirements wanneer je aanroeptlog_model. Zie Aangepaste UDF-afhankelijkheden.

De volgende code laat zien hoe u een nieuw model voor eindpunten maakt. Zie Aangepast model maken voor eindpunten voor meer informatie.

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

Een query uitvoeren op het eindpunt

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"},
    ],
)

Query's uitvoeren op het eindpunt met requestsource-functies

Als het model is getraind met RequestSource functies, moet de nettolading van de aanvraag ook alle RequestSource kolommen bevatten. Deze kolommen zijn toegevoegd aan de handtekening van het MLflow-model, log_modelzodat het API-schema van het eindpunt de vereiste aanvraagvelden weerspiegelt.

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)
        },
    ],
)

Entiteitssleutels worden gebruikt voor het opzoeken van functies die door tabellen worden ondersteund vanuit de online winkel. Een ColumnSelection kenmerk kan een RequestSource waarde doorgeven aan het model. Een CustomUDF feature transformeert zijn verzoekinvoer voordat het model het resultaat gebruikt.

U kunt ook het volgende gebruiken 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"
      }
    ]
  }'

Functies aanbieden met een FeatureSpec

Als u functieweergaven wilt leveren zonder een model, maakt u een FeatureSpec functie die verwijst naar de functies en implementeert u deze in een functieverdieningseindpunt. Het eindpunt retourneert alleen de feature-uitvoer die in de specificatie zijn gevraagd. Het berekent automatisch tussentijdse waarden zonder ze terug te geven, tenzij je die features ook aanvraagt.

Registreer alle featurefuncties in Unity Catalog en maak ondersteunde online materialisaties voor de leaves op basis van tabellen en streams voordat u het endpoint maakt.

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

Voer een query uit op het eindpunt met de entiteitssleutels die worden gebruikt om de gerealiseerde functies op te zoeken:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

Voor meer informatie over Feature Serving eindpunten, zie Serve feature tables.

Serveer CustomUDF-functies en hun afhankelijkheden

Dit voorbeeld ondersteunt de transactie- en margefunctionaliteiten die zijn gedefinieerd in de voorbeelden CustomUDF en FeatureViewSource. Gebruik databricks-feature-engineering versie 0.18.0 of hoger voor deze Feature Views API's.

• log_transaction_amount past transaction_amount toe op de main.ecommerce.log_amount_udf-waarde van het verzoek met NumPy.
• margin gebruikt FeatureViewSource om een marge te berekenen uit revenue_sum_7d en cost_sum_7d. Deze upstream-features gebruiken customer_id als entiteitssleutel en event_time als tijdreeks-kolom.

Registreer zowel outputfeatures als elke upstream-feature voordat je de specificatie aanmaakt. Voor dit voorbeeld materialiseer je online alleen de revenue_sum_7d en cost_sum_7d leaves. Serving zoekt hun waarden op en berekent margin voor elk verzoek.

Haal de geregistreerde Feature objecten op en geef ze door aan create_feature_spec. Verklaar NumPy voor online uitvoering, zelfs als het al in de clausule ENVIRONMENT van de UDF staat:

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"],
)

Volg de stappen voor het aanmaken van het eindpunt hierboven met feature_spec_name="main.ecommerce.derived_transaction_features" en een eindpuntnaam zoals derived-transaction-features. Nadat het eindpunt klaar is, geef je de lookup-sleutel en de request-time waarde in:

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},
    ],
)

De reactie bevat alleen de gevraagde log_transaction_amount en margin output, niet de tussenliggende omzet- en kostenwaardes. Voor afhankelijkheidsformaten, wheel-rechten en installatieprobleemoplossing, zie Add Python dependencies.