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 :

  • **Service de modèles** : Déployer un modèle qui a été entraîné sur des vues de fonctionnalités. Endpoint recherche automatiquement les valeurs de fonctionnalité dans le magasin en ligne, en utilisant la lignée suivie lors de l'enregistrement du modèle. Utilisez ceci pour servir des prédictions de modèle.
  • Feature Serving : Déployez un FeatureSpec qui référence directement les vues de fonctionnalités, sans modèle. L'endpoint renvoie les valeurs de fonctionnalité recherchées. Utilisez-le lorsqu'une application a besoin de valeurs de fonctionnalités plutôt que de prédictions de modèle.

Les deux approches lisent les valeurs de fonctionnalités précalculées à partir d'un magasin en ligne, vous devez donc d'abord matérialiser les fonctionnalités dans un magasin en ligne.

Les modèles qui sont entraînés à l'aide de fonctionnalités de Databricks suivent automatiquement la traçabilité jusqu'aux fonctionnalités sur lesquelles ils ont été entraînés. Lorsqu'ils sont déployés en tant qu'Endpoint de mise en service de modèle, ces modèles utilisent Unity Catalog pour rechercher des caractéristiques dans les magasins en ligne.

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.

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 les fonctionnalités basées sur des tables à partir du magasin en ligne. RequestSource colonnes sont transmises directement au modèle.

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 les Feature Views sans modèle, créez un FeatureSpec qui référence les fonctionnalités et déployez-le sur un Endpoint de Feature Serving. L'endpoint renvoie les valeurs de fonctionnalités recherchées pour les clés d'entité dans la requête.

Les fonctionnalités doivent être enregistrées dans Unity Catalog et matérialisées dans un magasin en ligne 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.

Sur cette page