Aller au contenu principal
Dernière mise à jour le

Servir les vues de fonctionnalités

info

Aperçu

Cette fonctionnalité est en Aperçu public. Les administrateurs du Workspace peuvent contrôler l'accès à cette fonctionnalité à partir de la page Previews . Consultez Gérer les aperçus Databricks.

Vous pouvez servir des Vues de fonctionnalités en ligne de deux manières :

  • Model serving : déployez un modèle qui a été entraîné sur des Feature Views. L'endpoint recherche ou compute des valeurs de fonctionnalités automatiquement, en utilisant le lineage suivi lors de l'enregistrement du modèle. Utilisez cette option pour servir des prédictions de modèle.
  • Feature Serving : déployez un FeatureSpec qui fait directement référence à des Feature Views, sans modèle. L'endpoint renvoie les sorties de fonctionnalités demandées. Utilisez cette option lorsqu'une application a besoin de valeurs de fonctionnalités plutôt que de prédictions de modèle.

Les deux approches prennent en charge les fonctionnalités précalculées et à la demande. Les caractéristiques de feuille adossées à une table et à un stream doivent disposer de matérialisations en ligne prises en charge. RequestSource fournit les valeurs de la requête et CustomUDF compute les fonctionnalités à la demande. Pour un CustomUDF avec FeatureViewSource, la diffusion résout les dépendances amont et évalue automatiquement le graphe de dépendance des fonctionnalités.

Enregistrez les fonctionnalités demandées et toutes leurs fonctionnalités amont transitives dans Unity Catalog. Matérialisez uniquement les feuilles basées sur des tables et des Stream, et non les fonctionnalités CustomUDF dérivées ou au moment de la requête.

Autorisations​

Pour servir une fonctionnalité, l'entité principale qui crée l'endpoint de service de modèle doit disposer de SELECT sur la table Unity Catalog qui prend en charge la fonctionnalité matérialisée. Les recherches en ligne lisent directement depuis la table matérialisée, donc le SELECT au niveau de la table accorde l'accès au service. Pour la description des privilèges, consultez SELECT.

Étant donné qu'une table matérialisée peut contenir plusieurs fonctionnalités, l'octroi de SELECT sur celle-ci donne accès à toutes les fonctionnalités de cette table, et pas seulement à celle que vous souhaitez servir. Avant d'accorder l'accès au service, confirmez que toutes les fonctionnalités partageant la table peuvent être partagées avec le principal. Pour limiter l'exposition, matérialisez les fonctionnalités sensibles séparément.

Pour accorder cet accès sans résoudre les tables manuellement, utilisez FeatureEngineeringClient.grant_feature_serving_access. Étant donné un modèle ou une spécification de fonctionnalité, il résout chaque fonctionnalité sur sa table en ligne, accorde SELECT (ainsi que USE CATALOG et USE SCHEMA) sur ces tables aux mandataires que vous spécifiez, et retourne un rapport de chaque table et les fonctionnalités supplémentaires que l'octroi expose. Veuillez passer dry_run=True pour prévisualiser le rapport avant d'accorder.

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

Déployer un endpoint de mise en service de modèle​

Utilisez un endpoint de service de modèle existant ou utilisez le SDK Databricks pour en créer un nouveau. Le modèle doit être enregistré dans Unity Catalog.

Si un CustomUDF utilise une UDF (user-defined function) qui importe des package Python, transmettez-les explicitement via extra_pip_requirements lorsque vous appelez log_model. Voir Dépendances d’UDF personnalisées.

Le code suivant montre comment créer un nouvel endpoint de service de modèle. Pour plus d’informations, consultez Créer des endpoints de service de modèle personnalisés.

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

Query l'Endpoint​

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

Interroger l'endpoint avec les fonctionnalités de RequestSource​

Si le modèle a été entraîné avec RequestSource fonctionnalités, la charge utile de la requête doit également inclure toutes les colonnes RequestSource. Ces colonnes ont été ajoutées à la signature du modèle MLflow pendant log_model, de sorte que le schéma de l'API de l'Endpoint reflète les champs de requête requis.

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

Les clés d’entité sont utilisées pour rechercher des fonctionnalités prises en charge par les tables à partir du magasin en ligne. Une fonctionnalité ColumnSelection peut transmettre une valeur RequestSource au modèle. Une fonctionnalité CustomUDF transforme ses entrées de requête avant que le modèle n’utilise le résultat.

Vous pouvez également utiliser curl:

Bash
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"
      }
    ]
  }'

Servez des fonctionnalités avec un FeatureSpec​

Pour servir des vues de fonctionnalités sans modèle, créez une FeatureSpec qui référence les fonctionnalités et déployez-la sur un endpoint Feature Serving. L’endpoint ne renvoie que les sorties de fonctionnalités demandées dans la spécification. Il calcule automatiquement les valeurs intermédiaires sans les renvoyer, sauf si vous demandez également ces fonctionnalités.

Enregistrez toutes les fonctionnalités dans Unity Catalog et créez des matérialisations en ligne prises en charge pour les feuilles reposant sur des tables et des Stream avant de créer l’Endpoint.

remarque

Un FeatureSpec qui contient des Vues de fonctionnalités ne peut pas non plus contenir de définitions FeatureLookup ou FeatureFunction. Les Vues de fonctionnalités ne peuvent pas être mélangées avec ces définitions dans le même FeatureSpec.

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

Query l'Endpoint avec les clés d'entité utilisées pour rechercher les fonctionnalités matérialisées :

Python
from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

Pour en savoir plus sur les Endpoint de Feature Serving, consultez Endpoint de Feature Serving.

Servez les fonctionnalités CustomUDF et leurs dépendances​

Cet exemple met en œuvre les features de transaction et de marge définies dans les exemples CustomUDF et FeatureViewSource. Utilisez la version databricks-feature-engineering 0.18.0 ou supérieure pour ces APIs Feature Views.

  • log_transaction_amount applique main.ecommerce.log_amount_udf à la valeur transaction_amount de la requête à l'aide de NumPy.
  • margin utilise FeatureViewSource pour compute une marge à partir de revenue_sum_7d et cost_sum_7d. Ces caractéristiques en amont utilisent customer_id comme clé d’entité et event_time comme colonne de séries temporelles.

Enregistrez à la fois les fonctionnalités de sortie et toutes les fonctionnalités en amont avant de créer la spécification. Pour cet exemple, matérialisez en ligne uniquement les feuilles revenue_sum_7d et cost_sum_7d. Le service recherche leurs valeurs et compute margin pour chaque requête.

Récupérez les objets Feature enregistrés et transmettez-les à create_feature_spec. Déclarez NumPy pour l'exécution en ligne même s'il figure déjà dans la clause ENVIRONMENT de l'UDF :

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

Suivez les étapes de création d'endpoint ci-dessus avec feature_spec_name="main.ecommerce.derived_transaction_features" et un nom d'endpoint tel que derived-transaction-features. Une fois l'endpoint prêt, fournissez la clé de recherche et la valeur au moment de la requête :

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

La réponse contient uniquement les sorties log_transaction_amount et margin demandées, et non les valeurs intermédiaires de revenus et de coûts. Pour en savoir plus sur les formats de dépendances, les autorisations des paquets wheel et le dépannage des installations, consultez Ajouter des dépendances Python.

Sur cette page