Traiter les affichages de fonctionnalités

Vous pouvez mettre des Feature Views en ligne de deux façons :

• Service de modèles : déployez un modèle entraîné sur des vues de fonctionnalités. Le point de terminaison recherche ou calcule automatiquement les valeurs des caractéristiques, en utilisant la lignée suivie lors de l’enregistrement du modèle. Utilisez ceci pour fournir les prédictions du modèle.
• Service des fonctionnalités : déployez un FeatureSpec qui référence directement les vues de fonctionnalités, sans modèle. Le point de terminaison renvoie les résultats des fonctionnalités demandé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 prennent en charge les fonctionnalités précalculées et à la demande. Les fonctionnalités terminales adossées à des tables et à des flux doivent avoir des matérialisations en ligne prises en charge. RequestSource fournit les valeurs de la requête, et CustomUDF calcule les fonctionnalités à la demande. Pour un CustomUDF avec FeatureViewSource, le service résout automatiquement les dépendances en amont et évalue automatiquement le graphe de dépendance des caractéristiques.

Inscrivez les fonctionnalités demandées ainsi que toutes leurs fonctionnalités transitives en amont dans le catalogue Unity. Ne matérialisez que les feuilles reposant sur des tables ou des flux, et non les caractéristiques au moment de la requête ou dérivées CustomUDF.

Permissions

Pour délivrer une fonctionnalité, le principal qui crée le points de terminaison de mise en service de modèles doit disposer de SELECT sur la table Unity Catalog sur laquelle repose la fonctionnalité matérialisée. Les recherches en ligne lisent directement dans la table matérialisée ; ce sont donc les SELECT au niveau de la table qui accordent l’accès. Pour obtenir la description des privilèges, consultez SELECT.

Comme une table matérialisée peut contenir plus d’une fonctionnalité, lui accorder SELECT donne accès à toutes les fonctionnalités de cette table, et pas seulement à celle que vous souhaitez exposer. Avant d’accorder l’accès aux services, vérifiez que chaque fonctionnalité partageant la table peut être partagée avec le principal. Pour limiter l’exposition, matérialisez séparément les caractéristiques sensibles.

Pour accorder cet accès sans résoudre les tables manuellement, utilisez FeatureEngineeringClient.grant_feature_serving_access. En fonction d’un modèle ou d’une spécification de fonctionnalité, il résout chaque fonctionnalité dans sa table en ligne, octroie SELECT (ainsi que USE CATALOGUSE SCHEMA) sur ces tables aux principaux que vous spécifiez et retourne un rapport de chaque table et les fonctionnalités supplémentaires exposées par l’octroi. Passez dry_run=True pour prévisualiser le rapport avant d’accorder l’autorisation.

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 point de terminaison de mise en service de modèles

Utilisez un point de terminaison de service de modèle existant ou utilisez le Kit de développement logiciel (SDK) Databricks pour en créer un nouveau. Le modèle doit être inscrit dans le catalogue Unity.

Si un CustomUDF utilise une fonction définie par l’utilisateur (UDF) qui importe des packages Python, transmettez-les explicitement via extra_pip_requirements lors de l’appel à log_model. Voir Dépendances UDF personnalisées.

Le code suivant illustre la manière de créer un point de terminaison de mise en service de modèles. Pour plus d'informations, consultez Créer des points d'accès de modèles personnalisés.

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

Interroger le point de terminaison

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 des fonctionnalités RequestSource, 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 d’API du point de terminaison reflète les champs de requête requis.

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 stockées dans une table à partir du magasin de fonctionnalités en ligne. Une ColumnSelection caractéristique peut transmettre une RequestSource valeur au modèle. Une CustomUDF caractéristique transforme ses entrées de requête avant que le modèle n’utilise le résultat.

Vous pouvez aussi utiliser 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"
      }
    ]
  }'

Délivrer des fonctionnalités avec un FeatureSpec

Pour diffuser des Feature Views sans modèle, créez un FeatureSpec qui référence les fonctionnalités et déployez-le sur un point de terminaison de diffusion des fonctionnalités. Le point de terminaison ne retourne que les sorties de fonctionnalités demandées dans la spécification. Il calcule automatiquement les valeurs intermédiaires sans les retourner, sauf si vous demandez aussi ces fonctionnalités.

Enregistrez toutes les caractéristiques dans Unity Catalog et créez les matérialisations en ligne prises en charge pour les feuilles basées sur des tables et des flux avant de créer le point de terminaison.

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

Interrogez le point de terminaison à l’aide des clés d’entité utilisées pour récupérer les caractéristiques matérialisées :

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 points de terminaison de mise en service de fonctionnalités, voir Mettre en service les tables de fonctionnalités.

Fonctionnalités CustomUDF de Serve et leurs dépendances

Cet exemple correspond aux caractéristiques de transaction et de marge définies dans les CustomUDF exemples et FeatureViewSource . Utilisez databricks-feature-engineering la version 0.18.0 ou supérieure pour ces API de Feature Views.

• log_transaction_amount applique main.ecommerce.log_amount_udf à la valeur transaction_amount de la requête avec NumPy.
• margin utilise FeatureViewSource pour calculer une marge à partir de revenue_sum_7d et cost_sum_7d. Ces fonctionnalités en amont servent customer_id de clé d’entité et event_time de colonne de série temporelle.

Enregistrez à la fois les variables de sortie et toutes les variables en amont avant de créer la spécification. Pour cet exemple, matérialisez en ligne uniquement les nœuds feuilles revenue_sum_7d et cost_sum_7d. Serving consulte leurs valeurs et calcule margin pour chaque requête.

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

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 du point de terminaison ci-dessus avec feature_spec_name="main.ecommerce.derived_transaction_features" et un nom de terminaison tel que derived-transaction-features. Une fois le point de terminaison prêt, fournissez la clé de recherche et la valeur du temps de requête :

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 demandées log_transaction_amount et margin, et non les valeurs intermédiaires de revenus et de coûts. Pour les formats des dépendances, les autorisations des fichiers wheel et la résolution des problèmes d’installation, consultez Ajouter des dépendances Python.