Matérialiser les affichages de fonctionnalités

Important

Cette fonctionnalité est disponible en préversion publique. Les administrateurs d’espace de travail peuvent contrôler l’accès à cette fonctionnalité à partir de la page Aperçus . Consultez Gérer les préversions d’Azure Databricks.

Une fois que vous avez créé vos définitions d’affichage des fonctionnalités, qui sont stockées dans le catalogue Unity, vous pouvez produire des données de fonctionnalités à partir de votre table source à l’aide des définitions de fonctionnalités. Ce processus est appelé matérialisation de vos fonctionnalités. Azure Databricks crée et gère des pipelines Lakeflow pour remplir des tables dans le catalogue Unity pour l’apprentissage des modèles et le scoring par lots ou le service en ligne.

Pour en savoir plus sur la diffusion des Feature Views, consultez Diffuser des Feature Views.

Spécifications

  • Les fonctionnalités doivent être créées en tant que vues de fonctionnalités et stockées dans le catalogue Unity.
  • Pour connaître la configuration requise pour la version, consultez Configuration requise.
  • ColumnSelection les fonctionnalités peuvent être matérialisées dans des magasins en ligne. Consultez matérialisation de la sélection de colonnes.
  • RequestSource les fonctionnalités ne peuvent pas être matérialisées, car elles représentent les données fournies au moment de l’inférence.

Permissions

La matérialisation interagit avec les privilèges Unity Catalog MANAGE et READ FEATURE pour cette fonctionnalité. Pour obtenir des descriptions complètes des privilèges, consultez READ FEATURE.

  • La matérialisation d’une fonctionnalité nécessite MANAGE. Appeler materialize_features ou delete_materialized_feature crée et gère les pipelines Lakeflow et les tables Unity Catalog sous-jacents ; il s’agit donc d’une opération de gestion. Vous devez avoir MANAGE pour la fonctionnalité, ainsi que READ FEATURE pour lire la définition de la fonctionnalité en cours de matérialisation.
  • La lecture des données matérialisées nécessite READ FEATURE. READ FEATURE sur la fonctionnalité accorde l’accès aux tables hors connexion et en ligne qui le sauvegardent, afin de pouvoir consommer les données matérialisées pour l’entraînement et le service du modèle. list_materialized_features nécessite READ FEATUREégalement .

Comme pour tout objet du catalogue Unity, vous devez également disposer de USE CATALOG sur le catalogue parent et de USE SCHEMA sur le schéma parent. READ FEATURE et MANAGE accordés sur un schéma ou un catalogue s’appliquent à toutes les fonctionnalités actuelles et futures qu’il contient.

Structures de données d’API

OfflineStoreConfig

Configuration du magasin hors connexion où les fonctionnalités matérialisées seront enregistrées. Lorsqu’materialize_features est appelé, le back-end du Feature Store crée des tables à l’aide de ce préfixe. Chaque exécution de pipeline matérialise les valeurs de fonctionnalités les plus récentes dans la table en fonction de la planification de matérialisation.

OfflineStoreConfig(
    catalog_name: str,        # Catalog name for the offline table where materialized features will be stored
    schema_name: str,         # Schema name for the offline table
    table_name_prefix: str    # Table name prefix for the offline table. The pipeline may create multiple tables with this prefix, each updated at different cadences
)

from databricks.feature_engineering.entities import OfflineStoreConfig

offline_store = OfflineStoreConfig(
    catalog_name="main",
    schema_name="feature_store",
    table_name_prefix="customer_features"
)

OnlineStoreConfig

Configuration du magasin en ligne, qui stocke les fonctionnalités utilisées par la mise en service de modèles. La matérialisation crée des tables Delta avec le catalog.schema.table_name_prefix et diffuse les tables vers le magasin de caractéristiques en ligne portant le même nom.

from databricks.feature_engineering.entities import OnlineStoreConfig

online_store = OnlineStoreConfig(
    catalog_name="main",
    schema_name="feature_store",
    table_name_prefix="customer_features_serving",
    online_store_name="customer_features_store"
)

MaterializedFeature

Représente une Feature View qui a été matérialisée, autrement dit, qui dispose d’une représentation pré-calculée dans Unity Catalog. Il existe des fonctionnalités matérialisées distinctes pour la table hors connexion et la table en ligne. En règle générale, les utilisateurs n’instancient pas directement un MaterializedFeature .

Appels de fonction API

materialize_features()

Matérialise une liste de vues de fonctionnalités soit dans une table Delta hors ligne, soit dans un magasin de fonctionnalités en ligne. Les fonctionnalités doivent être inscrites dans le catalogue Unity avant d’appeler cette fonction (par exemple, à l’aide create_feature ou register_feature). Les fonctionnalités construites localement qui n’ont pas été inscrites ne fonctionnent pas.

FeatureEngineeringClient.materialize_features(
    features: List[Feature],                                               # List of Feature Views to materialize
    offline_config: Optional[OfflineStoreConfig] = None,                   # Offline store config (aggregation features only)
    online_config: Optional[OnlineStoreConfig] = None,                     # Online store config
    trigger: Union[CronSchedule, TableTrigger, StreamingMode],              # Materialization trigger
) -> List[MaterializedFeature]:

La méthode retourne une liste de fonctionnalités matérialisées, qui contiennent des métadonnées sur le moment où les valeurs des fonctionnalités sont mises à jour et les tables du catalogue Unity où les fonctionnalités sont matérialisées.

Si un OnlineStoreConfig et un OfflineStoreConfig sont fournis, deux fonctionnalités matérialisées sont retournées par fonctionnalité fournie, une pour chaque type de magasin.

Le paramètre trigger contrôle quand le pipeline de matérialisation s’exécute :

  • CronSchedule: s’exécute selon une planification fixe. Obligatoire pour les fonctionnalités d’agrégation par lots (AggregationFunction à partir de DeltaTableSource).
  • TableTrigger: s’exécute lorsque la table Delta en amont reçoit une validation. Obligatoire pour les fonctionnalités ColumnSelection prises en charge par un DeltaTableSource.
  • StreamingMode: fonctionne comme pipeline de diffusion en continu. Obligatoire pour les fonctionnalités prises en charge par un StreamSource.

Vous ne pouvez pas combiner des fonctionnalités qui nécessitent différents types de déclencheurs dans un seul materialize_features appel. Émettre des appels distincts à la place.

Matérialiser le magasin hors connexion

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    CronSchedule, OfflineStoreConfig,
)

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=features,
    offline_config=OfflineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="customer_features"
    ),
    trigger=CronSchedule(
        quartz_cron_expression="0 0 * * * ?",  # Hourly
        timezone_id="UTC",
    ),
)

Matérialiser une boutique en ligne

Note

Pour matérialiser les fonctionnalités d’agrégation dans un magasin en ligne, vous devez également matérialiser un magasin hors connexion. Les deux offline_config et online_config sont obligatoires. Il online_store_name doit faire référence à un magasin de fonctionnalités en ligne existant. Pour obtenir des instructions sur la création d’une fonctionnalité, consultez Databricks Online Feature Stores.

Les fonctionnalités de ColumnSelection ne nécessitent pas de OfflineStoreConfig. Consultez matérialisation de la sélection de colonnes.

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    CronSchedule, OfflineStoreConfig, OnlineStoreConfig,
)

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=features,
    offline_config=OfflineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="customer_features"
    ),
    online_config=OnlineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="customer_features_serving",
        online_store_name="customer_features_store"
    ),
    trigger=CronSchedule(
        quartz_cron_expression="0 0 * * * ?",  # Hourly
        timezone_id="UTC",
    ),
)

Créer des fonctionnalités de streaming

Les fonctionnalités de diffusion en continu ne peuvent être matérialisées que dans des magasins en ligne ; le offline_config paramètre n’est pas pris en charge. La matérialisation hors ligne n’est pas prise en charge, car les fonctionnalités de streaming nécessitent un pipeline en temps réel pour garantir une fraîcheur inférieure à la seconde. Pour l’entraînement ou l’évaluation hors connexion, le client d’ingénierie des fonctionnalités récompose les valeurs des fonctionnalités en fonction de chaque point de données évalué.

Les fonctionnalités de streaming ne peuvent pas être mélangées à des fonctionnalités de traitement par lots dans le même materialize_features appel.

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    OnlineStoreConfig, StreamingMode,
)

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=[streaming_feature],
    online_config=OnlineStoreConfig(
        catalog_name="my_catalog",
        schema_name="my_schema",
        table_name_prefix="streaming_features_serving",
        online_store_name="feature_store_online"
    ),
    trigger=StreamingMode(),
)

list_materialized_features()

Retourne les matérialisations d’une seule fonctionnalité, identifiées par son nom complet. feature_name est obligatoire et uniquement par mot-clé. Pour examiner les matérialisations sur plusieurs attributs, commencez par lister les attributs dans un catalogue ou un schéma, puis appelez list_materialized_features pour chaque attribut renvoyé.

Par défaut, un maximum de 100 matérialisations sont retournées. Vous pouvez modifier cette limite à l’aide du max_results paramètre.

FeatureEngineeringClient.list_materialized_features(
    *,                                      # Arguments are keyword-only
    feature_name: str,                      # Required: full name of the feature whose materializations to list
    max_results: int = 100,                 # Maximum number of materializations to return
) -> List[MaterializedFeature]:

delete_materialized_feature()

Avant de supprimer une fonctionnalité matérialisée, supprimez ou mettez à jour des modèles ou des spécifications de fonctionnalités qui référencent la fonctionnalité.

Supprime une fonctionnalité matérialisée. La fonctionnalité à transmettre dépend du type de fonctionnalité :

  • Fonctionnalités d’agrégation : passez la fonctionnalité matérialisée hors connexion. S’il existe une fonctionnalité matérialisée en ligne pour la même fonctionnalité, les deux sont supprimées.
  • ColumnSelection fonctionnalités : passez la fonctionnalité matérialisée en ligne. ColumnSelection les fonctionnalités sont matérialisées uniquement dans le magasin en ligne (voir Matérialisation de la sélection de colonnes), par conséquent il n’existe aucune fonctionnalité hors connexion appairée.

Dans le cadre de la matérialisation, les fonctionnalités sont regroupées par source de données et par fenêtre d’agrégation pour plus d’efficacité. ColumnSelection les fonctionnalités n’ont aucune fenêtre d’agrégation. Elles sont donc regroupées uniquement par source de données. Le pipeline de matérialisation, la table hors connexion et la table en ligne ne sont pas supprimés tant que toutes les fonctionnalités groupées n’ont pas été supprimées. Lorsque la dernière fonctionnalité matérialisée d’un groupe est supprimée, le magasin de fonctionnalités planifie les ressources associées pour le nettoyage automatique par un processus en arrière-plan. Consultez le nettoyage des ressources en arrière-plan.

Pour nettoyer les fonctionnalités matérialisées, examinez la table associée à une fonctionnalité matérialisée. Chaque fonctionnalité de la table (une par colonne) doit être supprimée avant que les ressources de calcul et de table Delta soient nettoyées.

Utilisez list_materialized_features() pour obtenir l’argument materialized_feature.

FeatureEngineeringClient.delete_materialized_feature(
    materialized_feature: MaterializedFeature,  # Required: The materialized feature to delete
) -> None

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()

feature_names = [
    "main.feature_store.amount_sum_sliding_7d_1d",
    "main.feature_store.amount_sum_sliding_30d_1d",
    "main.feature_store.transaction_count_sliding_7d_1d",
    "main.feature_store.latest_transaction_amount",
    "main.feature_store.latest_user_tier",
]

for name in feature_names:
    mfs = fe.list_materialized_features(feature_name=name)   # required, keyword-only
    offline = [mf for mf in mfs if not mf.is_online]
    for mf in (offline or mfs):
        fe.delete_materialized_feature(materialized_feature=mf)
    fe.delete_feature(full_name=name)

Matérialisation de la sélection de colonnes

ColumnSelection les fonctionnalités sélectionnent la dernière valeur d’une seule colonne par clé d’entité sans agrégation. Ils ne peuvent être matérialisés que dans des magasins en ligne. Pour les cas d’usage hors connexion (apprentissage et inférence par lots), ColumnSelection les fonctionnalités sont extraites directement des données sources au moment de la requête, de sorte que la matérialisation hors connexion n’est pas nécessaire.

Comportement de matérialisation

  • Le pipeline écrit la ligne la plus récente pour chaque clé d’entité dans le tableau en ligne, sans fenêtre d’agrégation.
  • La matérialisation en ligne actualise la table en ligne avec la dernière valeur par clé d’entité.

Exemple

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    DeltaTableSource, Feature, ColumnSelection, TableTrigger, OnlineStoreConfig,
)

fe = FeatureEngineeringClient()

delta_source = DeltaTableSource(
    catalog_name="catalog",
    schema_name="schema",
    table_name="transactions",
)

amount_feature = Feature(
    source=delta_source,
    function=ColumnSelection("amount"),
    entity=["user_id"],
    timeseries_column="transaction_time",
    name="latest_transaction_amount",
)

# Register before materializing
amount_feature = fe.register_feature(
    feature=amount_feature,
    catalog_name="catalog",
    schema_name="schema",
)

mfs = fe.materialize_features(
    features=[amount_feature],
    online_config=OnlineStoreConfig(
        catalog_name="catalog",
        schema_name="feats_online",
        table_name_prefix="txn_",
        online_store_name="lb_usw2"
    ),
    trigger=TableTrigger(),
)

ColumnSelection utilise les fonctionnalités de TableTrigger, qui exécute le pipeline chaque fois que la table Delta source reçoit un nouveau commit. Aucun offline_config n'est nécessaire, car les caractéristiques de ColumnSelection sont lues directement à partir de la source pour les cas d’usage hors connexion (formation et inférence par lots).

Note

RequestSource les fonctionnalités ne peuvent pas être matérialisées, car elles représentent les données fournies par l’appelant au moment de l’inférence (ou extraites du DataFrame étiqueté au moment de l’entraînement). Il n’existe aucune table source à lire. Les valeurs existent uniquement dans la charge utile de la requête ou dans le DataFrame d’entraînement.

Nettoyage des ressources en arrière-plan

Lorsque vous supprimez une fonctionnalité matérialisée, Databricks supprime immédiatement les métadonnées de fonctionnalité. L’infrastructure associée (tables, pipelines et tâches) est nettoyée de manière asynchrone par un processus en arrière-plan.

Étant donné que plusieurs fonctionnalités matérialisées peuvent partager les mêmes tables et pipelines, ces ressources partagées ne sont pas supprimées tant que chaque fonctionnalité matérialisée qui les référence a été supprimée. Lorsque la dernière fonctionnalité matérialisée partageant un ensemble de tables est supprimée, le processus en arrière-plan supprime automatiquement les ressources suivantes :

  • Tables Delta hors connexion contenant les données de caractéristique matérialisées
  • Les tables en ligne, si les fonctionnalités ont été matérialisées dans un magasin en ligne
  • La chaîne de matérialisation
  • Travail d’orchestration

Ce processus en arrière-plan utilise un principal de service système géré par Databricks pour effectuer ces actions de nettoyage en votre nom, notamment la suppression de tables, de pipelines et de travaux dans votre espace de travail. Aucune action de votre part n’est nécessaire. Le nettoyage est entièrement géré par le feature store.

Note

Il peut y avoir un court délai entre la suppression de la dernière fonctionnalité matérialisée dans un groupe et la suppression des tables associées et d’autres ressources.

Afficher l’état de matérialisation

Pour afficher l’état de matérialisation de vos vues de fonctionnalités dans l’interface utilisateur de Databricks, y compris pour déboguer les erreurs de matérialisation, consultez Explorer les vues de fonctionnalités dans Unity Catalog.

Limites

Fonctionnalités par lot

  • Les pipelines de matérialisation par lots s’exécutent comme des pipelines Lakeflow sans serveur.
  • Les caractéristiques des fenêtre dynamiques par lots ne peuvent pas être matérialisées. En raison de leur haute fidélité en termes d’exactitude temporelle, les caractéristiques des fenêtres dynamiques pour l’apprentissage hors ligne ou l’inférence par lots sont générées à la volée pour chaque point de données.
  • ColumnSelection les fonctionnalités peuvent uniquement être matérialisées dans des magasins en ligne.
  • RequestSource les fonctionnalités ne peuvent pas être matérialisées.
  • Les fonctionnalités matérialisées ne peuvent être supprimées que dans l’espace de travail dans lequel elles ont été créées.
  • Pour les fonctionnalités d’agrégation matérialisées, la fonctionnalité matérialisée en ligne ne peut pas être supprimée directement. Supprimez la fonctionnalité matérialisée et hors ligne associée, et la modification se répercute sur les deux fonctionnalités.
  • Pour les fonctionnalités d’agrégation matérialisées créées avant le 20 avril 2026, le pipeline de matérialisation continue de produire de nouvelles valeurs de fonctionnalités jusqu’à ce que toutes les fonctionnalités matérialisées du pipeline aient été supprimées, ce qui déclenche le nettoyage des ressources. Pour créer un pipeline mis à jour qui prend en charge la suppression par fonctionnalité, supprimez et matérialisez à nouveau la fonctionnalité.
  • Pour les fonctionnalités matérialisées ColumnSelection, le pipeline de matérialisation continue de produire de nouvelles valeurs de fonctionnalités jusqu’à ce que toutes les fonctionnalités matérialisées du pipeline aient été supprimées, ce qui déclenche le nettoyage des ressources.

Fonctionnalités de diffusion en continu

  • Les fonctionnalités de diffusion en continu ne peuvent être matérialisées que dans des magasins en ligne. La matérialisation hors connexion n’est pas nécessaire, car les fonctionnalités de streaming au moment de l’entraînement sont conçues pour être recomputées à partir d’événements historiques par point de données pour fournir une précision au niveau de la milliseconde.
  • Les fonctionnalités de streaming ne peuvent pas être mélangées à des fonctionnalités de traitement par lots dans un seul materialize_features appel.
  • compute_features ne prend pas en charge les fonctionnalités de diffusion en continu.
  • L’espace de travail doit se trouver dans une région qui prend en charge les instances Lakebase.
  • Seuls les messages Kafka sérialisés JSON sont pris en charge. Les schémas de message doivent être fournis directement au format de schéma JSON. Les registres de schémas (Confluent, Glue) ne sont pas officiellement pris en charge pendant la préversion, mais si vous fournissez directement le schéma, les pipelines peuvent lire des rubriques régies par un registre de schémas.
  • Uniquement RollingWindow est pris en charge pour les fonctionnalités d’agrégation de streaming. TumblingWindow et SlidingWindow doit être utilisé avec les fonctionnalités de traitement par lots.
  • Seules Count, AvgSumStddevPopMax, Minet Last les fonctions d’agrégation sont prises en charge pour les fonctionnalités de streaming.
  • Les fonctionnalités de sélection de colonnes des sources de diffusion en continu ne gèrent pas les messages hors ordre. L’événement le plus récent sur le flux Kafka est affiché, même si la valeur de colonne timeseries est antérieure à un événement précédemment reçu.
  • Les pipelines de streaming sont redémarrés deux fois par semaine. Chaque redémarrage peut entraîner des retards de traitement et des temps de démarrage allant jusqu’à 1 minute. En excluant les redémarrages, l'actualisation au p99 est de 200 ms.
  • Le renvoi des fonctionnalités de la matérialisation n’est pas pris en charge. Lorsqu’une fonctionnalité est matérialisée, elle calcule à partir de ce point vers l’avant. Les agrégations nouvellement créées dans le magasin en ligne sont inexactes jusqu’à ce que leur fenêtre de temps soit passée.
  • Seul databricks Online Feature Store est pris en charge.
  • Seuls les catalogues standard dans le catalogue Unity créés dans votre propre stockage d’objets cloud sont pris en charge. Les catalogues créés dans le stockage par défaut ne peuvent pas être utilisés.
  • Les pipelines de matérialisation en continu s’exécutent sous forme de pipelines Lakeflow serverless.
  • Espaces de travail de niveau Entreprise uniquement.
  • Last updated on