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.

Prise en charge de la matérialisation par type de fonctionnalité​

La possibilité et l'emplacement de matérialisation d'une fonctionnalité dépendent de son type :

Les features qui ne se matérialisent que dans les magasins en ligne restent utilisables hors ligne : create_training_set et compute_features calculent leurs valeurs temporelles directement à partir de la source, de sorte qu’aucune matérialisation hors ligne n’est nécessaire.

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.

Matérialiser les dernières valeurs à fraîcheur limitée​

Une agrégation batch Last avec un RollingWindow donne à une entité en ligne une durée de vie (TTL) : sa valeur expire hors du magasin en ligne lorsqu’aucune valeur source ne se trouve dans la fenêtre. C’est utile lorsque l’âge d’une valeur détermine s’il est sûr de la servir. Par exemple, l'état d'un appareil de la dernière heure peut être servi, tandis qu'un état plus ancien renvoie une valeur nulle au lieu de rester disponible indéfiniment.

Un RollingWindow définit une durée explicite qui confère à la fonctionnalité un comportement similaire à un TTL. Par exemple, si la source publie des valeurs quotidiennement et que vous ne souhaitez conserver que celles des sept derniers jours, utilisez un RollingWindow avec une durée de sept jours. À chaque trigger, la matérialisation effectue un remplacement complet de la table en ligne, de sorte que les valeurs situées en dehors de la fenêtre sont supprimées selon un calendrier prévisible. Cela produit le même résultat qu’un Last en streaming doté d’un RollingWindow, mais coûte moins cher car il ne fait pas tourner de compute en continu.

Ce modèle de publication est similaire à une table de fonctionnalités dotée d'une durée de vie (TTL) publiée en mode instantané. Si vous maintenez un ensemble de tables de fonctionnalités et que vous souhaitez les utiliser aux côtés d'autres vues de fonctionnalités, vous pouvez les adapter au framework de création des vues de fonctionnalités. Utilisez un batch Last avec un RollingWindow et un TableTrigger.

Cette combinaison dispose d’un mode de matérialisation spécial en ligne uniquement, soumis aux exigences suivantes :

  • La source doit être un(e) DeltaTableSource.
  • La fonction d’agrégation doit être Last, et sa fenêtre doit être un RollingWindow.
  • La matérialisation doit fournir un OnlineStoreConfig, omettre OfflineStoreConfig et utiliser TableTrigger.

Dans l'exemple suivant, latest_device_state_1h est une fonctionnalité enregistrée qui répond à ces exigences :

Python
from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import OnlineStoreConfig, TableTrigger

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=[latest_device_state_1h],
    online_config=OnlineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="latest_device_state_serving",
        online_store_name="device_state_store",
    ),
    trigger=TableTrigger(),
)

Pour l'entraînement hors ligne et l'évaluation par batch, le client de Data Engineering calcule la valeur à un instant T directement à partir de la source. Il ne lit pas de matérialisation hors ligne pour cette fonctionnalité.

Considérations​

  • L’expiration avance uniquement sur un Trigger. La valeur en ligne et son expiration avancent lorsqu’un commit de table source déclenche un refresh de matérialisation. Le simple passage du temps ne Trigger pas de refresh. Si la source cesse de publier, la dernière valeur matérialisée reste dans le magasin en ligne jusqu’à ce qu’un commit ultérieur déclenche un refresh.
  • Alignez la colonne de séries temporelles sur l’heure de publication de la source. La colonne de séries temporelles doit refléter le moment où la source a publié les données. Sinon, les valeurs en ligne et hors ligne divergent, car le magasin en ligne effectue une jointure à l’heure du Trigger, tandis que les lectures hors ligne effectuent une jointure à l’heure des séries temporelles.
  • Définissez la durée de la fenêtre sur un multiple de la cadence de publication. Si la durée RollingWindow n’est pas un multiple de la cadence de publication de la source, certaines valeurs sont considérées comme expirées lors de l’entraînement hors ligne alors qu’elles sont toujours visibles en ligne.

Fonctionnalités à la demande et matérialisation​

RequestSource les valeurs proviennent du DataFrame d’entraînement ou de la requête d’inférence, il n’y a donc pas de table source à matérialiser. Les fonctionnalités FeatureViewSource appliquent un CustomUDF aux valeurs de fonctionnalités en amont lors de l’entraînement ou du service. Elles ne stockent pas de résultat précalculé. La matérialisation n’est pas non plus prise en charge pour les fonctionnalités CustomUDF associées à une table Delta.

Pour un graphe de dépendances tel que revenue_sum_7d et cost_sum_7d alimentant une fonctionnalité margin :

  • Pour l’entraînement hors ligne, appelez create_training_set avec margin. Il résout les fonctionnalités en amont et compute les valeurs ponctuelles, en utilisant des matérialisations hors ligne compatibles lorsqu’elles sont disponibles.
  • Pour le service en ligne, matérialisez les caractéristiques de revenus et de coûts prises en charge dans un store en ligne. L’endpoint les recherche et calcule margin pour chaque requête.
  • Transmettez uniquement les fonctionnalités en amont prises en charge à materialize_features, et non margin ou toute autre fonctionnalité basée sur les requêtes. La matérialisation ne matérialise pas de manière récursive les dépendances d’une fonctionnalité dérivée.

Un graphe qui utilise uniquement des fonctionnalités basées sur les requêtes ne nécessite pas de magasin en ligne. Voir Entraîner avec des fonctionnalités FeatureViewSource et Servir des fonctionnalités dérivées.

Autorisations​

La matérialisation nécessite des privilèges sur la caractéristique ainsi que sur les ressources source et de destination. Pour obtenir une description complète des privilèges Unity Catalog, consultez la référence des privilèges Unity Catalog.

  • La matérialisation d'une entité nécessite MANAGE. L'appel de materialize_features crée et gère les LakeFlow pipelines sous-jacents ainsi que les tables Unity Catalog. Il s'agit donc d'une opération de gestion. Vous devez disposer de MANAGE sur l'entité, ainsi que de READ FEATURE pour lire la définition de l'entité en cours de matérialisation.

  • La suppression d'une entité matérialisée est réservée à son créateur. Seul l'utilisateur qui a créé une entité matérialisée peut la supprimer avec delete_materialized_feature. Cette restriction est indépendante des privilèges Unity Catalog : MANAGE sur l'entité ou son schéma parent ne permet pas à un autre utilisateur de la supprimer.

  • La lecture des données sources nécessite SELECT. Pour une fonctionnalité qui utilise une source de table Delta, vous devez disposer de SELECT sur la table source. Pour une fonctionnalité qui utilise une source Stream, vous devez disposer de SELECT sur la table d'ingestion du Stream.

    Pour les autres autorisations requises par la configuration d'authentification d'un Stream, consultez Kafka authentication.

  • La création de tables de destination requiert CREATE TABLE. Vous devez disposer de CREATE TABLE sur chaque schéma spécifié par OfflineStoreConfig ou OnlineStoreConfig. Les destinations hors ligne et en ligne peuvent se trouver dans des schémas ou des catalogues différents, et la matérialisation nécessite des privilèges sur chaque destination.

  • La matérialisation vers une boutique en ligne nécessite CAN USE. Vous devez disposer de CAN USE sur l'instance Lakebase ou le projet utilisé par la boutique en ligne. Pour plus d'information concernant les autorisations Lakebase, consultez Accorder les autorisations de projet.

  • L’affichage de la liste des fonctionnalités matérialisées nécessite READ FEATURE sur la fonctionnalité parente. Pour utiliser list_materialized_features, vous devez disposer de READ FEATURE sur la fonctionnalité qui a été matérialisée.

  • La lecture de données matérialisées requiert SELECT. Vous devez disposer de SELECT sur chaque table de sortie hors ligne ou en ligne à laquelle vous accédez. READ FEATURE sur la entité parente n’accorde pas l’accès à ces tables.

Pour chaque ressource Unity Catalog impliquée dans la matérialisation, vous avez également besoin de USE CATALOG sur son catalogue parent et de USE SCHEMA sur son schéma parent. Cette exigence s'applique à la fonctionnalité, à chaque source ou table d'ingestion Stream, ainsi qu'à chaque destination configurée. 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 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(
    *,                                                                     # Arguments are keyword-only
    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
    tags: Optional[Dict[str, str]] = None,                                 # Custom tags for cost attribution
    budget_policy_id: Optional[str] = None,                                # Serverless usage policy for cost attribution
) -> 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 une planification dérivée de la temporisation de la fonctionnalité ou selon un calendrier cron Quartz fourni par l'appelant. Pris en charge 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. Pris en charge pour les fonctionnalités ColumnSelection et les fonctionnalités d'agrégation (AggregationFunction) prises en charge par un DeltaTableSource. Pour les fonctionnalités d'agrégation, le pipeline est limité pour s'exécuter au plus une fois par moitié de la granularité de la fonctionnalité (la durée de glissement pour une fenêtre glissante ou la longueur de la fenêtre pour une fenêtre fixe), plafonné à 1 heure et jamais plus souvent que toutes les 5 minutes. Par exemple, au plus une fois toutes les 30 minutes pour une granularité d'une heure, ou au plus une fois par heure pour une granularité de 2 heures ou plus. L'intervalle est mesuré à partir de l'exécution précédente, de sorte qu'un commit qui arrive après son expiration déclenche tout de même rapidement une exécution.
  • 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.

Pour attribuer le coût d’une matérialisation, passez tags, budget_policy_id ou les deux. Databricks les applique au job ou au pipeline qu’il crée, de sorte que sa consommation soit imputée à votre attribution dans la table système d’utilisation facturable. Les deux sont appliqués lors de la création ; par conséquent, attribuer différemment une matérialisation existante implique d’en créer une nouvelle. budget_policy_id prend l’ID d’une politique d’utilisation serverless. Pour en créer une et obtenir son ID, consultez Créer une politique d’utilisation serverless. Pour en savoir plus sur les limites de tags, les ressources atteintes par chaque valeur et la façon de query les dépenses attribuées, consultez Gestion des coûts du Magasin de fonctionnalité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 la plupart des fonctionnalités d’agrégation vers un online store, vous devez également effectuer une matérialisation vers un offline store. offline_config et online_config sont tous deux 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 d’un Magasin de fonctionnalités Databricks, consultez Online Feature Stores Databricks.

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

Le cas particulier du batch Last avec RollingWindow est également exclusivement en ligne. Consultez Matérialiser les dernières valeurs limitées par la fraîcheur.

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 les matérialisations d'une seule fonctionnalité, identifiée par son nom complet. feature_name est requis et exclusivement par mot-clé. Pour examiner les matérialisations pour plusieurs fonctionnalités, commencez par lister les fonctionnalités dans un catalogue ou un schéma, puis appelez list_materialized_features sur chaque fonctionnalité renvoyée.

Par default, un maximum de 100 matérialisations sont retournées. Vous pouvez modifier cette limite à l’aide du parameter max_results.

Python
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 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é :

  • Caractéristiques d'agrégation : passez 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. Pour un batch Last de fonctionnalités en ligne uniquement avec un RollingWindow, passez la fonctionnalité matérialisée en ligne.
  • 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

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)

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 le statut de matérialisation de vos Feature Views dans l’interface utilisateur Databricks et déboguer les erreurs de matérialisation, consultez Explorer les Feature Views 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, à l'exception du cas particulier Last réservé en ligne décrit dans la section Materialize freshness-bounded latest values. Pour l'entraînement hors ligne ou l'inférence par batch, les fonctionnalités de fenêtre glissante sont calculées à partir des données source pour chaque recherche à un point spécifique du temps.
  • ColumnSelection Les fonctionnalités peuvent être matérialisées uniquement dans des magasins en ligne.
  • RequestSource, les fonctionnalités FeatureViewSource et CustomUDF ne peuvent pas être matérialisées. Voir les fonctionnalités à la demande et la matérialisation.
  • Les fonctionnalités matérialisées ne peuvent être supprimées que dans le Workspace dans lequel elles ont été créées.
  • Seul l'utilisateur qui a créé une entité matérialisée peut la supprimer, quels que soient les privilèges Unity Catalog sur l'entité ou son schéma parent.
  • 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, First, Last, FirstN, LastN, FirstDistinct et LastDistinct 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.
  • Les pipelines de matérialisation en streaming s'exécutent en tant que LakeFlow pipelines Serverless.
  • Workspaces de niveau Enterprise uniquement.
Sur cette page