Aller au contenu principal
Dernière mise à jour le

Matérialiser 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.

Après avoir créé vos définitions de vue de fonctionnalités, qui sont stockées dans Unity Catalog, vous pouvez produire des données de fonctionnalités à partir de votre table source en utilisant les définitions de fonctionnalités. Ce processus est appelé matérialisation de vos fonctionnalités. Databricks crée et gère des LakeFlow Pipelines pour alimenter les tables dans Unity Catalog pour l'entraînement de modèles et le scoring par batch ou le service en ligne.

Pour plus d'informations sur le service des vues de fonctionnalités, consultez Servir les vues de fonctionnalités.

Exigences​

  • Les fonctionnalités doivent être créées en tant que Vues de fonctionnalités et stockées dans Unity Catalog.
  • Pour les exigences de version, voir les exigences.
  • ColumnSelection Les fonctionnalités peuvent être matérialisées dans des magasins en ligne. Consultez la matérialisation de la sélection de colonnes.
  • RequestSource Les fonctionnalités ne peuvent pas être matérialisées car elles représentent des données fournies au moment de l'inférence.

Autorisations​

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

  • La matérialisation d’une fonctionnalité nécessite MANAGE. L’appel de materialize_features ou delete_materialized_feature crée et gère les LakeFlow Pipelines et les tables Unity Catalog sous-jacentes. Il s’agit donc d’une opération de gestion. Vous devez disposer de MANAGE sur la fonctionnalité, ainsi que de 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 ligne et en ligne qui la soutiennent, afin que vous puissiez consommer les données matérialisées pour l'entraînement et le service de modèles. list_materialized_features nécessite également READ FEATURE.

Comme pour tout objet Unity Catalog, vous avez également besoin de USE CATALOG sur le catalogue parent et de USE SCHEMA sur le schéma parent. Les READ FEATURE et MANAGE accordées sur un schéma ou un catalogue s'appliquent à tous les éléments actuels et futurs qu'il contient.

Structures de données API​

OfflineStoreConfig​

Configuration du magasin hors ligne où les fonctionnalités matérialisées seront écrites. Lorsque materialize_features est appelé, le backend du Magasin de fonctionnalités crée des tables en utilisant ce préfixe. Chaque exécution de pipeline matérialise les dernières valeurs de fonctionnalité dans la table selon le calendrier de matérialisation.

Python
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
)
Python
from databricks.feature_engineering.entities import OfflineStoreConfig

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

OnlineStoreConfig​

Configuration pour le magasin en ligne, qui stocke les fonctionnalités utilisées par la diffusion de modèles. La matérialisation crée des tables Delta avec le catalog.schema.table_name_prefix et diffuse les tables en streaming vers l'Online Magasin de fonctionnalités sous le même nom.

Python
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 vue de fonctionnalités qui a été matérialisée, c'est-à-dire qui dispose d'une représentation précalculée disponible dans Unity Catalog. Il existe des fonctionnalités matérialisées distinctes pour la table hors ligne et la table en ligne. Généralement, les utilisateurs n'instancieront pas un MaterializedFeature directement.

Appels de fonction d'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 enregistrées dans Unity Catalog avant d'appeler cette fonction (par exemple, en utilisant create_feature ou register_feature). Les fonctionnalités construites localement qui n'ont pas été enregistrées ne fonctionneront pas.

Python
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 renvoie une liste de fonctionnalités matérialisées, qui contiennent des métadonnées sur la date de mise à jour des valeurs de fonctionnalités et les tables Unity Catalog où les fonctionnalités sont matérialisées.

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

Le paramètre trigger détermine quand le pipeline de matérialisation s'exécute :

  • CronSchedule : S'exécute selon un calendrier fixe. Requis pour les fonctionnalités d'agrégation par batch (AggregationFunction à partir de DeltaTableSource).
  • TableTrigger : s’exécute lorsque la table Delta en amont reçoit un commit. Requis pour les fonctionnalités ColumnSelection prises en charge par un DeltaTableSource.
  • StreamingMode ** ** : s'exécute comme un pipeline de streaming continu. Requis pour les fonctionnalités soutenues par un StreamSource.

Vous ne pouvez pas mélanger des fonctionnalités qui requièrent des types de Trigger différents dans un seul appel materialize_features. Lancez plutôt des appels séparés.

Matérialiser vers un stockage hors ligne​

Python
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 vers le magasin en ligne​

remarque

Pour matérialiser les fonctionnalités d'agrégation vers un magasin en ligne, vous devez également matérialiser vers un magasin hors ligne. Les offline_config et online_config sont requis. Le online_store_name doit faire référence à un Magasin de fonctionnalités en ligne existant. Pour obtenir des instructions sur la création, consultez les Magasins de fonctionnalités en ligne Databricks.

ColumnSelection les fonctionnalités ne nécessitent pas de OfflineStoreConfig. Voir Matérialisation ColumnSelection.

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

Matérialiser les fonctionnalités de streaming​

Les fonctionnalités de streaming ne peuvent être matérialisées que dans des magasins en ligne ; le parameter offline_config 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 actualisation en moins d'une seconde. Pour la formation ou l'évaluation hors ligne, le client d'ingénierie des fonctionnalités recalculera les valeurs des fonctionnalités en fonction de chaque point de données évalué.

Les fonctionnalités de streaming ne peuvent pas être combinées avec les fonctionnalités batch dans le même appel materialize_features.

Python
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()​

Renvoie une liste de toutes les fonctionnalités matérialisées dans le métastore Unity Catalog de l'utilisateur.

Par default, un maximum de 100 fonctionnalités sont renvoyées. Vous pouvez modifier cette limite à l’aide du parameter max_results.

Pour filtrer les fonctionnalités matérialisées renvoyées par nom de fonctionnalité, utilisez le parameter feature_name facultatif.

Python
FeatureEngineeringClient.list_materialized_features(
    feature_name: Optional[str] = None,     # Optional feature name to filter by
    max_results: int = 100,                 # Maximum number of features to be returned
) -> List[MaterializedFeature]:

delete_materialized_feature()​

Avant de supprimer une fonctionnalité matérialisée, supprimez ou mettez à jour tous les modèles ou 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** : Transmettez la fonctionnalité matérialisée hors ligne. S'il existe une fonctionnalité matérialisée en ligne pour la même fonctionnalité, les deux sont supprimées.
  • ColumnSelection fonctionnalités : Transmettez la fonctionnalité matérialisée en ligne. Les fonctionnalités ColumnSelection sont matérialisées uniquement dans le magasin en ligne (voir la matérialisation de ColumnSelection), il n'y a donc pas de fonctionnalité hors ligne associé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 fonctionnalités n'ont pas de fenêtre d'agrégation, elles sont donc regroupées uniquement par source de données. Le pipeline de matérialisation, la table hors ligne 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 programme les ressources associées pour un nettoyage automatique par un processus d'arrière-plan. Consultez la page 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 le nettoyage des ressources compute et des tables Delta.

Utilisez list_materialized_features() pour obtenir l'argument materialized_feature.

Python
FeatureEngineeringClient.delete_materialized_feature(
    materialized_feature: MaterializedFeature,  # Required: The materialized feature to delete
) -> None
Python
from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import ColumnSelection

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:
    feature = fe.get_feature(full_name=name)
    for mf in fe.list_materialized_features(feature_name=name):
        if isinstance(feature.function, ColumnSelection):
            # ColumnSelection features only have online materializations. Delete the online materialized feature directly.
            fe.delete_materialized_feature(materialized_feature=mf)
        elif not mf.is_online:
            # Aggregation features have both offline and online materializations. Delete the offline materialized feature to delete both.
            fe.delete_materialized_feature(materialized_feature=mf)
        # Online materialized aggregation features cannot be deleted directly. They are deleted via their paired offline materialized features.

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. Elles ne peuvent être matérialisées que dans des boutiques en ligne. Pour les cas d’utilisation hors ligne (entraînement et inférence par batch), les ColumnSelection fonctionnalités sont récupérées directement à partir des données source au moment de la query, de sorte que la matérialisation hors ligne n’est pas nécessaire.

Comportement de matérialisation​

  • Le pipeline écrit la ligne la plus récente par clé d'entité dans la table en ligne, sans fenêtre d'agrégation.
  • La matérialisation en ligne alimente la table en ligne avec la dernière valeur actuelle par clé d'entité.

Exemple​

Python
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 les fonctionnalités utilisent TableTrigger, ce 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 fonctionnalités ColumnSelection sont lues directement depuis la source pour les cas d'utilisation hors ligne (entraînement et inférence par batch).

remarque

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'y a pas de table source à partir de laquelle lire. Les valeurs existent uniquement dans la charge utile de la requête ou 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 la fonctionnalité. L'infrastructure associée (tables, pipelines et Jobs) 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 supprimées que lorsque 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 :

  • Les tables Delta hors ligne contenant les données de fonctionnalité matérialisées
  • Les tables en ligne, si les fonctionnalités ont été matérialisées dans un magasin en ligne
  • Le pipeline de matérialisation
  • Le Job d'orchestration

Ce processus en arrière-plan utilise un Service Principal système géré par Databricks pour effectuer ces actions de nettoyage en votre nom, y compris la suppression de tables, de pipelines et de Jobs dans votre Workspace. Aucune action n'est requise de votre part. Le nettoyage est entièrement managé par le Magasin de fonctionnalités.

remarque

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.

Statut de matérialisation de la vue​

Pour afficher l'état de matérialisation de vos vues de fonctionnalités dans l'interface utilisateur de Databricks, y compris le debugging des erreurs de matérialisation, consultez Explorer les vues de fonctionnalités dans Unity Catalog.

Limitations​

Fonctionnalités batch​

  • Les pipelines de matérialisation par batch s'exécutent en tant que LakeFlow Pipelines Serverless.
  • Les fonctionnalités de fenêtre glissante par batch ne peuvent pas être matérialisées. En raison de leur grande fidélité de correction temporelle, les fonctionnalités de fenêtre glissante pour l'entraînement hors ligne ou l'inférence par batch sont générées à la volée pour chaque point de données.
  • ColumnSelection Les fonctionnalités peuvent être matérialisées uniquement 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 le Workspace dans lequel elles ont été créées.
  • Pour les fonctionnalités d'agrégation matérialisée, la fonctionnalité matérialisée en ligne ne peut pas être supprimée directement. Supprimez la fonctionnalité matérialisée hors ligne appairée, et la modification se propage aux deux.
  • 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 rematérialisez la fonctionnalité.
  • Pour les fonctionnalités ColumnSelection matérialisées, le pipeline de matérialisation continue de produire de nouvelles valeurs de fonctionnalité jusqu'à ce que toutes les fonctionnalités matérialisées du pipeline aient été supprimées, ce qui Trigger le nettoyage des Ressources.

Fonctionnalités de streaming​

  • Les fonctionnalités de streaming ne peuvent être matérialisées que dans des magasins en ligne. La matérialisation hors ligne n'est pas nécessaire car les fonctionnalités de streaming au moment de l'entraînement sont conçues pour être recalculées à partir d'événements historiques par point de données afin de fournir une précision au niveau de la milliseconde.
  • Les fonctionnalités de streaming ne peuvent pas être mélangées avec les fonctionnalités de batch dans un seul appel materialize_features.
  • compute_features ne prend pas en charge les fonctionnalités de streaming.
  • Le workspace doit être 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 JSON Schema. Les registres de schémas (Confluent, Glue) ne sont pas formellement pris en charge pendant l'aperçu, mais si vous fournissez le schéma directement, les pipelines peuvent lire à partir de sujets régis par un registre de schémas.
  • Seul RollingWindow est pris en charge pour les fonctionnalités d'agrégation de streaming. TumblingWindow et SlidingWindow doivent être utilisés avec les fonctionnalités batch.
  • Seules les fonctions d’agrégation Count, Avg, Sum, StddevPop, Max, Min et Last sont prises en charge pour les fonctionnalités de streaming.
  • Les fonctionnalités de sélection de colonne des sources de streaming ne gèrent pas les messages désordonnés. Le dernier événement sur le Stream Kafka est affiché, même si la valeur de la colonne de la série chronologique 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 délais de traitement et des Startup times allant jusqu'à 1 minute. À l'exclusion des redémarrages, la fraîcheur p99 est de 200 ms.
  • Le remplissage de fonctionnalités pour la matérialisation n'est pas pris en charge. Lorsqu'une fonctionnalité est matérialisée, elle est calculée à partir de ce moment-là. Les agrégations nouvellement créées dans le magasin en ligne sont inexactes tant que leur fenêtre temporelle n'est pas passée.
  • Seul le Magasin de fonctionnalités en ligne Databricks est pris en charge.
  • Seuls les catalogues standards dans Unity Catalog créés dans votre propre stockage d'objets cloud sont pris en charge. Les catalogues créés dans le default storage ne peuvent pas être utilisés.
  • Les pipelines de matérialisation en streaming s'exécutent en tant que LakeFlow pipelines Serverless.
  • Workspaces de niveau Enterprise uniquement.
Sur cette page