Verwalten Sie Feature-Ansichten mit deklarativen Automatisierungsbündeln

Important

Dieses Feature befindet sich in der privaten Vorschauphase. Wenden Sie sich an Ihren Azure Databricks-Kontakt, um es zu testen.

Deklarative Automatisierungspakete (früher bekannt als Databricks Asset Bundles) ermöglichen es Ihnen, Azure Databricks-Ressourcen wie Feature Views und die Pipelines, die sie materialisieren, programmatisch zu validieren, bereitzustellen und auszuführen. Erfahren Sie , was deklarative Automatisierungspakete sind?.

Dieses Tutorial stellt ein Bundle zusammen, das vier Feature Views deklariert und sie auf drei Arten materialisiert: zwei Batch-Funktionen, die sowohl in einen Offline- als auch in einen Online-Shop geschrieben werden, eine kontinuierlich in einen Online-Shop geschriebene Streaming-Funktion sowie eine Streaming-Funktion mit einem Sägezahnfenster, das im Batch-Modus in einen Offline- und einen Online-Shop sowie im Streaming-Modus in den Online-Shop materialisiert wird. Dann änderst du die Konfiguration, deployest neu und baust alles ab.

Das Deklarieren von Funktionen in einem Bundle liefert dir dieselben Definitionen in jedem Arbeitsbereich, in den du deployest, und sie werden zusammen mit dem Rest deines Projekts als Quelle überprüft. Es ist die deklarative Alternative zum Aufrufen von create_feature und materialize_features aus einem Notizbuch. Siehe Funktionsansichten.

Jeder Schritt zeigt die Konfiguration sowohl in YAML als auch in Python. Wähle eine Sprache und die Seite wird entsprechend deiner Auswahl angezeigt.

Requirements

Eine Quelltabelle und ein Stream haben jeweils ihren eigenen Lebenszyklus, und keine von beiden ist eine Bundle-Ressource. Erstelle sie zuerst und verweise sie im Bundle nach Namen, so wie Schritt 3 für die Tabelle und Schritt 4 für den Stream.

Feature Store-Ressourcen in einem Bundle

Ein Bundle deklariert zwei Feature-Store-Ressourcentypen, und der Unterschied zwischen ihnen bestimmt, was eine Bereitstellung kostet.

  • Feature View: die Definition eines Features, die ihre Quelle, ihre Aggregation und ihre Schlüssel abdeckt. Es handelt sich um leichtgewichtige Metadaten. Siehe Feature Views und hinsichtlich der Konfigurationsreferenz feature.
  • Materialisierungsmenge: eine Gruppe materialisierter Merkmale. Ein materialisiertes Feature ist eine Feature View, die über Pipelines oder Jobs in einer Tabelle materialisiert wird, das ist also die aufwendigere Hälfte. Das Gruppieren der materialisierten Features in einer Gruppe teilt Azure Databricks mit, dass sie zusammen berechnet werden können, sodass sie in die wenigsten Tabellen und Lakeflow-Pipelines gepackt werden, die sie enthalten. Siehe Materialize Feature Views und für die Konfigurationsreferenz materialization_set und materialization_set.materialized_features.

Die folgenden Schritte deklarieren Batch-Features, ein Streaming-Feature und ein Streaming-Feature mit Sägezahnfenster. Deklariere nur die, die dein Projekt benötigt. Wie die Materialisierung funktioniert, erfahren Sie unter Materialize Feature Views.

Schritt 1: Einrichten der Authentifizierung

Richte zuerst die Authentifizierung zwischen der Databricks-CLI auf deinem Entwicklungsrechner und deinem Azure Databricks-Arbeitsbereich ein. Bei dieser Seite wird davon ausgegangen, dass Sie die OAuth-Authentifizierung User-to-Machine (U2M) und ein entsprechendes Azure Databricks-Konfigurationsprofil namens DEFAULT für die Authentifizierung verwenden möchten.

Note

Die U2M-Authentifizierung eignet sich für das Testen dieser Schritte in Echtzeit. Bei vollständig automatisierten Workflows empfiehlt Databricks stattdessen die Verwendung der OAuth-M2M-Authentifizierung (Machine-to-Machine, Computer-zu-Computer). Lesen Sie die Anweisungen zum Einrichten der M2M-Authentifizierung unter Autorisieren des Dienstprinzipalzugriffs auf Azure Databricks mit OAuth.

  1. Verwenden Sie die Databricks CLI, um die OAuth-Tokenverwaltung lokal zu initiieren, indem Sie den folgenden Befehl für jeden Zielarbeitsbereich ausführen.

    Ersetzen Sie <workspace-url> im folgenden Befehl durch Ihre arbeitsbereichsspezifische Azure Databricks-URL, z. B. https://adb-1234567890123456.7.azuredatabricks.net.

    databricks auth login --host <workspace-url>
    
  2. Die Databricks-CLI fordert Sie auf, die von Ihnen eingegebenen Informationen als Azure Databricks-Konfigurationsprofil zu speichern. Drücken Sie Enter, um den vorgeschlagenen Profilnamen zu übernehmen, oder geben Sie den Namen eines neuen oder bereits vorhandenen Profils ein. Ist bereits ein Profil mit dem gleichen Namen vorhanden, wird es mit den von Ihnen eingegebenen Informationen überschrieben. Sie können Profile verwenden, um Ihren Authentifizierungskontext schnell über mehrere Arbeitsbereiche hinweg zu wechseln.

    Verwenden Sie zum Abrufen einer Liste vorhandener Profile in einem separaten Terminal oder einer separaten Eingabeaufforderung die Databricks CLI, um den Befehl databricks auth profiles auszuführen. Um die vorhandenen Einstellungen eines bestimmten Profils anzuzeigen, führen Sie den Befehl databricks auth env --profile <profile-name>aus.

  3. Führen Sie in Ihrem Webbrowser die Anweisungen auf dem Bildschirm aus, um sich bei Ihrem Azure Databricks-Arbeitsbereich anzumelden.

  4. Um den aktuellen OAuth-Tokenwert eines Profils und den bevorstehenden Ablaufzeitstempel eines Profils anzuzeigen, führen Sie einen der folgenden Befehle aus:

    • databricks auth token --host <workspace-url>
    • databricks auth token -p <profile-name>
    • databricks auth token --host <workspace-url> -p <profile-name>

    Wenn Sie über mehrere Profile mit demselben --host-Wert verfügen, müssen Sie möglicherweise die Optionen --host und -p zusammen angeben, damit die Databricks CLI die richtigen übereinstimmenden Informationen des OAuth-Tokens ermitteln kann.

Schritt 2: Erstellen des Pakets

Erstelle ein leeres Verzeichnis für das Bundle, mit einer databricks.yml Datei an der Wurzel und einem resources Verzeichnis daneben.

YAML

Jeder der folgenden Schritte fügt eine Datei unter resources/ zur Deklaration von Bundle-Ressourcen hinzu:

databricks.yml
resources/
  batch_feature.yml
  streaming_feature.yml
  streaming_feature_sawtooth.yml

databricks.yml enthält drei Dinge:

  • Der Name des Bundle.
  • Der include Eintrag, der entscheidet, aus welchen Dateien das Bundle seine Ressourcen lädt.
  • Die Variablen, die Werte enthalten, auf die Ressourcen verweisen können, wie Katalog, Schema und Quellnamen.
bundle:
  name: feature-store-quickstart

include:
  - resources/*.yml

variables:
  catalog:
    description: The catalog that features are written to.
    default: main
  schema:
    description: The schema that features are written to.
    default: features_demo
  source_table:
    description: The three-level name of the source Delta table.
    default: main.features_demo.transactions
  stream:
    description: The three-level name of a Stream registered in Unity Catalog.
    default: main.features_demo.events
  online_store:
    description: The online store that serves the features.
    default: my_online_store

Stattdessen alles in databricks.yml zu deklarieren funktioniert auch. Lassen Sie include weg und sammeln Sie die Deklarationen jedes Schrittes unter einer Abbildung resources:

bundle:
  name: feature-store-quickstart

variables:
  # The variables above.

resources:
  features:
    # The Feature Views from the following steps.
  materialization_sets:
    # The materialization sets from the following steps.

Python

In Python deklarierte Ressourcen werden nur durch die python Abbildung in databricks.ymlgefunden. Ohne sie validiert und deployt das Bundle erfolgreich, enthält aber keine Ressourcen, also fügen Sie es jetzt hinzu:

bundle:
  name: feature-store-quickstart

python:
  venv_path: .venv
  resources:
    - 'resources:load_resources'

variables:
  catalog:
    description: The catalog that features are written to.
    default: main
  schema:
    description: The schema that features are written to.
    default: features_demo
  source_table:
    description: The three-level name of the source Delta table.
    default: main.features_demo.transactions
  stream:
    description: The three-level name of a Stream registered in Unity Catalog.
    default: main.features_demo.events
  online_store:
    description: The online store that serves the features.
    default: my_online_store

venv_path ist die virtuelle Umgebung, in der die Databricks CLI diesen Code ausführt. Jeder Eintrag unter resources gibt eine Funktion als <module>:<function> an, die Databricks CLI aufruft, um die Ressourcen des Bündels zu sammeln. Wenn mehr als ein <module>:<function> Eintrag unter deklariert resourceswird, ruft Databricks CLI jede Funktion auf und sammelt die Ressourcen, die jede zurückgibt.

Erstellen Sie dann das Projekt und seine virtuelle Umgebung und fügen Sie das Paket hinzu:

uv init --bare
uv venv .venv
uv add databricks-bundles

Erzeugen Sie resources/__init__.py mit der Funktion, die databricks.yml benennt:

from databricks.bundles.core import Bundle, Resources


def load_resources(bundle: Bundle) -> Resources:
    resources = Resources()
    # The following steps add resources here.
    return resources

Weitere Informationen zum Erstellen von Bundles in Python, einschließlich der Projektvorlage und Mutatoren, finden Sie unter Bundle-Konfiguration in Python.

Schritt 3: Hinzufügen von Batch-Funktionen

Diese beiden Feature Views zählen Transaktionen pro Nutzer über sieben und 30 Tage nachlaufend, beide täglich neu berechnet und gemeinsam in einem Offline- und einem Online-Shop materialisiert.

Eine Feature View für sich genommen ist nur eine Definition. Die Materialisierungsmenge ist das, was daraus Daten erzeugt.

Jede Ressource trägt zwei Namen. transaction_count ist der Ressourcenschlüssel: ein von Ihnen gewählter Name, der innerhalb des Bundles eindeutig ist und den databricks bundle-Befehle zur Adressierung der Ressource verwenden und auf den andere Konfigurationsreferenzen verweisen. Zum Beispiel beziehen sich die beiden materialisierten Merkmale von transaction_count in der Menge transactions auf den Namen der Feature View als ${resources.features.transaction_count.full_name}, was dem Bündel signalisiert, dass die Menge von der Feature View transaction_countabhängt.

Aufgrund dieser Abhängigkeit wird transaction_count vor dem Set transactions erstellt, wenn beide erstellt werden, und nach dem Set transactions gelöscht, wenn beide zerstört werden. Ein fest programmierter Name wie main.features_demo.transaction_count_7d, geschrieben ohne ${}, lässt diese Abhängigkeit weg und wird in unvorhersehbarer Reihenfolge bereitgestellt.

full_name ist der dreistufige Name, den du für die Feature View wählst, um sie unter Unity Catalog zu registrieren, und der Namen, den du später anfragst. Die beiden Namen sind unabhängig voneinander.

Eine Dauer ist eine Anzahl von Sekunden mit dem Suffix s, also 604800s für sieben Tage. Siehe Spezifizierung einer Dauer für ein Fenster, eine Quelle oder Funktion.

Jeder Eintrag darunter materialized_features ist ein materialisiertes Feature-Mitglied: eine Feature View, die zu einem Ziel materialisiert wird. Jede dieser Feature-Ansichten materialisiert sich sowohl als Offline- als auch als Online-Ziel, sodass jede zwei materialisierte Feature-Mitglieder beiträgt und jedes Mitglied seinen eigenen Trigger mitbringt. Beide Feature Views schreiben an dasselbe Offline- und Online-Ziel, da ein Set ein Offline-Ziel und höchstens ein Online-Ziel hat.

YAML

Erstellen Sie resources/batch_feature.yml:

resources:
  features:
    transaction_count:
      full_name: ${var.catalog}.${var.schema}.transaction_count_7d
      description: Transactions per user over a trailing seven days
      source:
        delta_table_source:
          full_name: ${var.source_table}
      function:
        aggregation_function:
          count_function:
            input: transaction_id
          time_window:
            sliding:
              window_duration: 604800s
              slide_duration: 86400s
      entities:
        - name: user_id
      timeseries_column:
        name: transaction_time

    transaction_count_30d:
      full_name: ${var.catalog}.${var.schema}.transaction_count_30d
      description: Transactions per user over a trailing 30 days
      source:
        delta_table_source:
          full_name: ${var.source_table}
      function:
        aggregation_function:
          count_function:
            input: transaction_id
          time_window:
            sliding:
              window_duration: 2592000s
              slide_duration: 86400s
      entities:
        - name: user_id
      timeseries_column:
        name: transaction_time

  materialization_sets:
    transactions:
      materialized_features:
        # Batch offline materialized feature of transaction_count.
        - feature_name: ${resources.features.transaction_count.full_name}
          offline_store_config:
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: transactions_offline
          cron_schedule_trigger:
            mode: DERIVED
        # Batch online materialized feature of transaction_count.
        - feature_name: ${resources.features.transaction_count.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: transactions_online
          cron_schedule_trigger:
            mode: DERIVED
        # Batch offline materialized feature of transaction_count_30d.
        - feature_name: ${resources.features.transaction_count_30d.full_name}
          offline_store_config:
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: transactions_offline
          cron_schedule_trigger:
            mode: DERIVED
        # Batch online materialized feature of transaction_count_30d.
        - feature_name: ${resources.features.transaction_count_30d.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: transactions_online
          cron_schedule_trigger:
            mode: DERIVED

Python

Füge die Importe zu resources/__init__.py hinzu:

from databricks.bundles.features import (
    AggregationFunction,
    CountFunction,
    DataSource,
    DeltaTableSource,
    EntityColumn,
    Feature,
    Function,
    SlidingWindow,
    TimeWindow,
    TimeseriesColumn,
)
from databricks.bundles.materialization_sets import (
    CronSchedule,
    CronScheduleMode,
    MaterializationSet,
    MaterializedFeature,
    OfflineStoreConfig,
    OnlineStoreConfig,
)

Dann fügen Sie dies zum Body von load_resources hinzu:

resources.add_feature(
    'transaction_count',
    Feature(
        full_name='${var.catalog}.${var.schema}.transaction_count_7d',
        description='Transactions per user over a trailing seven days',
        source=DataSource(delta_table_source=DeltaTableSource(full_name='${var.source_table}')),
        function=Function(
            aggregation_function=AggregationFunction(
                count_function=CountFunction(input='transaction_id'),
                time_window=TimeWindow(
                    sliding=SlidingWindow(window_duration='604800s', slide_duration='86400s')
                ),
            )
        ),
        entities=[EntityColumn(name='user_id')],
        timeseries_column=TimeseriesColumn(name='transaction_time'),
    ),
)

resources.add_feature(
    'transaction_count_30d',
    Feature(
        full_name='${var.catalog}.${var.schema}.transaction_count_30d',
        description='Transactions per user over a trailing 30 days',
        source=DataSource(delta_table_source=DeltaTableSource(full_name='${var.source_table}')),
        function=Function(
            aggregation_function=AggregationFunction(
                count_function=CountFunction(input='transaction_id'),
                time_window=TimeWindow(
                    sliding=SlidingWindow(window_duration='2592000s', slide_duration='86400s')
                ),
            )
        ),
        entities=[EntityColumn(name='user_id')],
        timeseries_column=TimeseriesColumn(name='transaction_time'),
    ),
)

resources.add_materialization_set(
    'transactions',
    MaterializationSet(
        materialized_features=[
            # Batch offline materialized feature of transaction_count.
            MaterializedFeature(
                feature_name='${resources.features.transaction_count.full_name}',
                offline_store_config=OfflineStoreConfig(
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='transactions_offline',
                ),
                cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
            ),
            # Batch online materialized feature of transaction_count.
            MaterializedFeature(
                feature_name='${resources.features.transaction_count.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='transactions_online',
                ),
                cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
            ),
            # Batch offline materialized feature of transaction_count_30d.
            MaterializedFeature(
                feature_name='${resources.features.transaction_count_30d.full_name}',
                offline_store_config=OfflineStoreConfig(
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='transactions_offline',
                ),
                cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
            ),
            # Batch online materialized feature of transaction_count_30d.
            MaterializedFeature(
                feature_name='${resources.features.transaction_count_30d.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='transactions_online',
                ),
                cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
            ),
        ]
    ),
)

Schritt 4: Fügen Sie eine Streaming-Funktion hinzu

Diese Feature-Ansicht zählt Ereignisse pro Schlüssel über die zurückliegenden 90 Minuten und materialisiert kontinuierlich in den Online-Store. Es schreibt an ein Ziel, daher deklariert seine Menge ein einzelnes Member.

Ein Mitglied eines materialisierten Streaming-Features trägt streaming_mode und keine cron_schedule_trigger. Für die Modi und was jeder davon bedeutet, siehe materialization_set.materialized_features.streaming_mode.

Dies ist ein zweites Materialisierungsset und nicht ein materialisiertes Merkmal, das dem in Schritt 3 definierten Set hinzugefügt wurde, da ein Materialisierungsset keine im Streaming-Modus materialisierten Feature-Views mit Feature-Ansichten, die in Batch materialisiert wurden, kombinieren kann. Eine Streaming-Feature-Ansicht mit Sägezahnfenster ist die Ausnahme. Seine Batch- und Streaming-Features gehören wie in Schritt 5 zum selben Set.

Die Feature-Ansicht liest einen Stream anhand des Namens. Ein Stream wird eigenständig, außerhalb des Bundles, erstellt und versioniert, ähnlich wie die Delta-Tabelle, die das Batch-Feature liest. Um einen zu erstellen, siehe Einen Stream erstellen.

Ein Streaming Feature View adressiert eine Eingabespalte als Pfad in den Stream-Datensatz und nicht als einfachen Spaltennamen, also ersetzt man die Namen, die das Schema Ihres Streams verwendet, dort, wo die Beispiele zeigen value.*.

YAML

Erstellen Sie resources/streaming_feature.yml:

resources:
  features:
    event_count_90m:
      full_name: ${var.catalog}.${var.schema}.event_count_90m
      description: Events per key over a trailing 90 minutes
      source:
        stream_source:
          full_name: ${var.stream}
      function:
        aggregation_function:
          count_function:
            input: value.amount
          time_window:
            rolling:
              window_duration: 5400s
      entities:
        - name: value.key
      timeseries_column:
        name: value.event_timestamp

  materialization_sets:
    events_online:
      materialized_features:
        - feature_name: ${resources.features.event_count_90m.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: event_count_90m_online
          streaming_mode:
            mode: STREAMING_MODE_TYPE_RTM

Python

Füge RollingWindow und StreamSource zu den Importen von databricks.bundles.features und StreamingMode und StreamingModeStreamingModeType zu den Importen von databricks.bundles.materialization_sets hinzu und füge dann dies zu load_resources hinzu:

resources.add_feature(
    'event_count_90m',
    Feature(
        full_name='${var.catalog}.${var.schema}.event_count_90m',
        description='Events per key over a trailing 90 minutes',
        source=DataSource(stream_source=StreamSource(full_name='${var.stream}')),
        function=Function(
            aggregation_function=AggregationFunction(
                count_function=CountFunction(input='value.amount'),
                time_window=TimeWindow(rolling=RollingWindow(window_duration='5400s')),
            )
        ),
        entities=[EntityColumn(name='value.key')],
        timeseries_column=TimeseriesColumn(name='value.event_timestamp'),
    ),
)

resources.add_materialization_set(
    'events_online',
    MaterializationSet(
        materialized_features=[
            MaterializedFeature(
                feature_name='${resources.features.event_count_90m.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='event_count_90m_online',
                ),
                streaming_mode=StreamingMode(
                    mode=StreamingModeStreamingModeType.STREAMING_MODE_TYPE_RTM
                ),
            )
        ]
    ),
)

Schritt 5: Fügen Sie ein Streaming-Feature mit einem Sägezahnfenster hinzu

Das Materialisieren einer Streaming-Feature View, deren Aggregation ein Sägezahnfenster verwendet, erzeugt drei materialisierte Features: ein offline materialisiertes Batch-Feature, ein online materialisiertes Batch-Feature und ein online materialisiertes Streaming-Feature. Der Server benötigt alle drei, und die Deklaration einer Teilmenge der materialisierten Features wird abgelehnt. Die beiden Batch-materialisierten Features müssen cron_schedule_trigger als DERIVED verwenden, sodass Azure Databricks den Zeitplan aus der Feature-Definition auswählt. Die Batch-Online-Materialisierungsfunktion und die Streaming-Online-Materialisierungsfunktion müssen dieselbe Online-Store-Konfiguration teilen. Ein Materialisierungsset, das diese Anforderungen nicht erfüllt, wird beim Deployment abgelehnt. Die vollständige Liste finden Sie unter Regeln, die ein Materialisierungssatz erfüllen muss.

YAML

Erstellen Sie resources/streaming_feature_sawtooth.yml:

resources:
  features:
    amount_sum:
      full_name: ${var.catalog}.${var.schema}.amount_sum_3d
      description: Sum of amount per key over a sawtooth window
      source:
        stream_source:
          full_name: ${var.stream}
      function:
        aggregation_function:
          sum:
            input: value.amount
          time_window:
            sawtooth:
              window_duration: 259200s
      entities:
        - name: value.key
      timeseries_column:
        name: value.event_timestamp

  materialization_sets:
    amounts:
      materialized_features:
        # Batch offline materialized feature.
        - feature_name: ${resources.features.amount_sum.full_name}
          offline_store_config:
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: amount_sum_offline
          cron_schedule_trigger:
            mode: DERIVED
        # Batch online materialized feature.
        - feature_name: ${resources.features.amount_sum.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: amount_sum_online
          cron_schedule_trigger:
            mode: DERIVED
        # Streaming online materialized feature.
        - feature_name: ${resources.features.amount_sum.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: amount_sum_online
          streaming_mode:
            mode: STREAMING_MODE_TYPE_RTM

Python

Füge SawtoothWindow und SumFunction zu den Importen von databricks.bundles.features hinzu, dann füge dies zu load_resources hinzu:

resources.add_feature(
    'amount_sum',
    Feature(
        full_name='${var.catalog}.${var.schema}.amount_sum_3d',
        description='Sum of amount per key over a sawtooth window',
        source=DataSource(stream_source=StreamSource(full_name='${var.stream}')),
        function=Function(
            aggregation_function=AggregationFunction(
                sum=SumFunction(input='value.amount'),
                time_window=TimeWindow(sawtooth=SawtoothWindow(window_duration='259200s')),
            )
        ),
        entities=[EntityColumn(name='value.key')],
        timeseries_column=TimeseriesColumn(name='value.event_timestamp'),
    ),
)

resources.add_materialization_set(
    'amounts',
    MaterializationSet(
        materialized_features=[
            # Batch offline materialized feature.
            MaterializedFeature(
                feature_name='${resources.features.amount_sum.full_name}',
                offline_store_config=OfflineStoreConfig(
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='amount_sum_offline',
                ),
                cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
            ),
            # Batch online materialized feature.
            MaterializedFeature(
                feature_name='${resources.features.amount_sum.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='amount_sum_online',
                ),
                cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
            ),
            # Streaming online materialized feature.
            MaterializedFeature(
                feature_name='${resources.features.amount_sum.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='amount_sum_online',
                ),
                streaming_mode=StreamingMode(
                    mode=StreamingModeStreamingModeType.STREAMING_MODE_TYPE_RTM
                ),
            ),
        ]
    ),
)

Schritt 6: Validieren und planen

Überprüfen Sie die Konfiguration, die databricks.yml und jede Ressourcendatei liest, die das Bundle lädt:

databricks bundle validate

validate ist auch der günstigste Weg, um herauszufinden, ob ein Feld akzeptiert wird. Es benennt jedes Feld, das das Bündel nicht erkennt, mit seinem Pfad sowie der Datei und der Zeile, von der es stammt:

Warning: unknown field: bogus_field
  at resources.features.transaction_count.function.aggregation_function.time_window.sliding
  in resources/batch_feature.yml:16:15

Ein nicht erkanntes Feld wird als Warnung gemeldet und sein Wert wird weggelassen; lesen Sie daher die Ausgabe und nicht nur den Exit-Code. Geben Sie --strict an, um Warnungen als Fehler zu behandeln. Zu den von jedem Fenster, jeder Funktion und jeder Quelle akzeptierten Feldern siehe feature.

Regeln, die der Server durchsetzt, wie die Regel, dass eine Feature View mit einem Sägezahnfenster alle drei materialisierten Features deklarieren muss, werden hier nicht geprüft und werden unter databricks bundle deploy angezeigt.

Dann überprüfe, was die Bereitstellung macht, bevor sie ausgeführt wird:

databricks bundle plan

Bei einer ersten Bereitstellung melden alle sieben Ressourcen (vier Feature Views und drei Materialisierungssets) create:

create features.amount_sum
create features.event_count_90m
create features.transaction_count
create features.transaction_count_30d
create materialization_sets.amounts
create materialization_sets.events_online
create materialization_sets.transactions

Plan: 7 to add, 0 to change, 0 to delete, 0 unchanged

Führe auch bei jeder weiteren Änderung plan aus, um zu sehen, welche Aktion geplant ist.

Schritt 7: Bereitstellen

Stellen Sie das Bundle in Ihrem Arbeitsbereich bereit:

databricks bundle deploy

Die Bereitstellung meldet jede Ressource, während sie erstellt wird:

Uploading bundle files to /Workspace/Users/someone@example.com/.bundle/feature-store-quickstart/default/files...
Created features.transaction_count_30d
Created features.transaction_count
Created features.amount_sum
Created features.event_count_90m
Created materialization_sets.transactions
Created materialization_sets.events_online
Created materialization_sets.amounts
Files: 4 uploaded, 0 deleted
Resources: 7 created, 0 changed, 0 deleted, 0 unchanged

Schritt 8: Überprüfe, was erstellt wurde

databricks bundle summary -o json meldet deine Bundle-Konfiguration mit den Ressourcen-Identifikatoren, wie der Materialisierungsset-ID, die beim letzten Deployment aufgezeichnet wurde. Für den in Schritt 5 definierten Materialisierungssatz:

{
  "id": "1234567890abcdef1234567890abcdef",
  "materialized_features": [
    {
      "cron_schedule_trigger": {
        "mode": "DERIVED"
      },
      "feature_name": "${resources.features.amount_sum.full_name}",
      "offline_store_config": {
        "catalog_name": "main",
        "schema_name": "features_demo",
        "table_name_prefix": "amount_sum_offline"
      }
    },
    {
      "cron_schedule_trigger": {
        "mode": "DERIVED"
      },
      "feature_name": "${resources.features.amount_sum.full_name}",
      "online_store_config": {
        "catalog_name": "main",
        "online_store_name": "my_online_store",
        "schema_name": "features_demo",
        "table_name_prefix": "amount_sum_online"
      }
    },
    {
      "feature_name": "${resources.features.amount_sum.full_name}",
      "online_store_config": {
        "catalog_name": "main",
        "online_store_name": "my_online_store",
        "schema_name": "features_demo",
        "table_name_prefix": "amount_sum_online"
      },
      "streaming_mode": {
        "mode": "STREAMING_MODE_TYPE_RTM"
      }
    }
  ]
}

Um zu sehen, was auf dem Server gespeichert ist, lesen Sie den Setback mit dem Befehl Feature Engineering und verwenden die id aus der databricks bundle summary Ausgabe:

databricks feature-engineering get-materialization-set <materialization-set-id>

Die Antwort enthält das, was der Server für dasselbe Set gespeichert hat, einschließlich der Felder, die er erzeugt:

{
  "materialization_set_id": "1234567890abcdef1234567890abcdef",
  "materialized_features": [
    {
      "cron_schedule_trigger": {
        "cron_expression": "0 0 2 * * ?",
        "mode": "DERIVED",
        "timezone_id": "UTC"
      },
      "feature_name": "main.features_demo.amount_sum_3d",
      "is_online": true,
      "job_id": 123456789012345,
      "materialization_set_id": "1234567890abcdef1234567890abcdef",
      "materialized_feature_id": "22222222222222222222222222222222",
      "online_store_config": {
        "catalog_name": "",
        "online_store_name": "my_online_store",
        "schema_name": "",
        "table_name_prefix": ""
      },
      "pipeline_schedule_state": "ACTIVE",
      "table_name": "main.features_demo.amount_sum_online_ceq88t"
    },
    {
      "feature_name": "main.features_demo.amount_sum_3d",
      "is_online": true,
      "job_id": 234567890123456,
      "materialization_set_id": "1234567890abcdef1234567890abcdef",
      "materialized_feature_id": "33333333333333333333333333333333",
      "online_store_config": {
        "catalog_name": "",
        "online_store_name": "my_online_store",
        "schema_name": "",
        "table_name_prefix": ""
      },
      "pipeline_id": "12345678-1234-1234-1234-123456789012",
      "pipeline_schedule_state": "ACTIVE",
      "streaming_mode": {
        "mode": "STREAMING_MODE_TYPE_RTM"
      },
      "table_name": "main.features_demo.amount_sum_online_qiohun"
    },
    {
      "cron_schedule_trigger": {
        "cron_expression": "0 0 2 * * ?",
        "mode": "DERIVED",
        "timezone_id": "UTC"
      },
      "feature_name": "main.features_demo.amount_sum_3d",
      "is_online": false,
      "job_id": 123456789012345,
      "materialization_set_id": "1234567890abcdef1234567890abcdef",
      "materialized_feature_id": "11111111111111111111111111111111",
      "pipeline_schedule_state": "ACTIVE",
      "table_name": "main.features_demo.amount_sum_offline_ceq88t"
    }
  ]
}

Schritt 9: Änderung der Konfiguration

Die folgenden Beispiele ändern die Feature Views und Materialization Sets aus früheren Schritten und zeigen, was jede Änderung bei der Bereitstellung bewirkt. Sofern kein Beispiel einen anderen Startpunkt nennt, beginnt jeder Punkt mit der Bereitstellung in Schritt 7. Jede ist eine Bearbeitung der Datei, die die Ressource deklariert, oder an der databricks.yml-Zuordnung in resources, falls du alles in einer Datei deklariert hast. Im Tab Python erfolgt die Bearbeitung in resources/__init__.py. Welche Änderungen direkt angewendet werden, welche die Ressource ersetzen und welche abgelehnt werden, siehe Changing a Feature View und Changing a materialization set.

Entfernen aller materialisierten Features einer Feature View

Das Entfernen aller materialisierten Merkmale einer Feature View aus einer Materialisierungsmenge wird an Ort und Stelle angewendet, sodass keine Feature-Daten neu berechnet werden. Siehe Änderung eines Materialisierungssets.

Im Folgenden wird die in transaction_count definierte Menge für Feature Views transaction_count_30d und transactions verwendet, und jedes materialisierte Merkmal der Feature View transaction_count_30d wird entfernt. Die materialisierten Merkmale von transaction_count in derselben Menge sind unberührt:

YAML

 materialization_sets:
   transactions:
     materialized_features:
       # Batch offline materialized feature of transaction_count.
       - feature_name: ${resources.features.transaction_count.full_name}
         offline_store_config: # As in Step 3.
         cron_schedule_trigger:
           mode: DERIVED
       # Batch online materialized feature of transaction_count.
       - feature_name: ${resources.features.transaction_count.full_name}
         online_store_config: # As in Step 3.
         cron_schedule_trigger:
           mode: DERIVED
-      # Batch offline materialized feature of transaction_count_30d.
-      - feature_name: ${resources.features.transaction_count_30d.full_name}
-        offline_store_config: # As in Step 3.
-        cron_schedule_trigger:
-          mode: DERIVED
-      # Batch online materialized feature of transaction_count_30d.
-      - feature_name: ${resources.features.transaction_count_30d.full_name}
-        online_store_config: # As in Step 3.
-        cron_schedule_trigger:
-          mode: DERIVED

Python

 resources.add_materialization_set(
     'transactions',
     MaterializationSet(
         materialized_features=[
             # Batch offline materialized feature of transaction_count.
             MaterializedFeature(...),  # As in Step 3.
             # Batch online materialized feature of transaction_count.
             MaterializedFeature(...),  # As in Step 3.
-            # Batch offline materialized feature of transaction_count_30d.
-            MaterializedFeature(...),  # As in Step 3.
-            # Batch online materialized feature of transaction_count_30d.
-            MaterializedFeature(...),  # As in Step 3.
         ]
     ),
 )

databricks bundle plan meldet den Satz als Aktualisierung:

update materialization_sets.transactions

Plan: 0 to add, 1 to change, 0 to delete, 6 unchanged

Änderung eines unveränderlichen Feldes einer Feature View

Wenn eine Materialisierungsmenge von einer Feature View abhängt, scheitert die Änderung eines unveränderlichen Feldes der Feature View beim Deployen. Das Ersetzen der Feature View löscht sie zuerst, und die Löschung wird abgelehnt, solange die Feature View materialisierte Features enthält. Welche Felder unveränderlich sind und wie Sie diese am besten ändern, finden Sie unter Ändern einer Feature-Ansicht.

Das Folgende nimmt die in transaction_count definierte Merkmalsansicht und erweitert deren Dauer des gleitenden Fensters, die ein unveränderliches Feld ist:

YAML

   features:
     transaction_count:
       # The other keys, as in Step 3.
       function:
         aggregation_function:
           count_function:
             input: transaction_id
           time_window:
             sliding:
-              window_duration: 604800s
+              window_duration: 1209600s
               slide_duration: 86400s

Python

 resources.add_feature(
     'transaction_count',
     Feature(
         # The other arguments, as in Step 3.
         function=Function(
             aggregation_function=AggregationFunction(
                 count_function=CountFunction(input='transaction_id'),
                 time_window=TimeWindow(
-                    sliding=SlidingWindow(window_duration='604800s', slide_duration='86400s')
+                    sliding=SlidingWindow(window_duration='1209600s', slide_duration='86400s')
                 ),
             )
         ),
     ),
 )

databricks bundle plan meldet eine Neuerstellung:

recreate features.transaction_count

Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged

databricks bundle deploy bittet um Bestätigung, und in der Nachricht steht, warum die Änderung nicht wie geschrieben durchgehen kann:

This action will result in the deletion or recreation of the following Feature Views.
A Feature View that has materialized features in a materialization set cannot be deleted or
recreated. Remove its materialized features from the set in a separate deploy first, then delete
or recreate the Feature View. Deleting or recreating a Feature View that a FeatureSpec serves is
not blocked, and leaves the FeatureSpec stale:
  recreate resources.features.transaction_count

Wenn Sie zustimmen, scheitert die Bereitstellung, weil das Set transactions weiterhin die beiden materialisierten Features der Feature View enthält:

Error: cannot recreate resources.features.transaction_count: deleting old id=main.features_demo.transaction_count_7d: Cannot delete feature 'main.features_demo.transaction_count_7d' because it has 2 materialized feature(s). Delete all materialized features first before deleting the feature. (400 BAD_REQUEST)

Um die Änderung vorzunehmen, deployen Sie zweimal, wie in Changing a Feature View beschrieben:

  1. Entferne die materialisierten Features der Feature View aus dem Set und deploye. Das Set wird an Ort und Stelle aktualisiert, wie beim Entfernen aller materialisierten Features einer Feature-Ansicht.

  2. Ändere die Feature View, füge ihre materialisierten Features wieder zum Set hinzu und deploye. Der Plan erstellt die Feature View für das geänderte Fenster neu und erstellt das Set neu, weil das Hinzufügen materialisierter Merkmale zu einem Set dieses ersetzt:

    Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_7d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed
    Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_7d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed
    recreate features.transaction_count
    recreate materialization_sets.transactions
    
    Plan: 2 to add, 0 to change, 2 to delete, 5 unchanged
    

    Nachdem Sie freigegeben haben, erstellt der Deploy die Feature View erneut und dann das Set erneut:

    Recreated features.transaction_count
    Recreated materialization_sets.transactions
    Files: 3 uploaded, 0 deleted
    Resources: 2 created, 0 changed, 2 deleted, 5 unchanged
    

Änderung eines unveränderlichen Felds eines Materialisierungssatzes

Das Ändern eines Feldes eines beliebigen materialisierten Merkmals in einer Menge ersetzt das gesamte Materialisierungsset, einschließlich der materialisierten Merkmale, die die Bearbeitung nicht betrifft. Siehe Änderung eines Materialisierungssets.

Im Folgenden wird die in transactions definierte Menge verwendet, und das table_name_prefix ihres Online-Ziels wird geändert, obwohl es unveränderlich ist. Beide online materialisierten Features tragen das Präfix, da das Set ein Online-Ziel hat:

YAML

 materialization_sets:
   transactions:
     materialized_features:
       # Batch offline materialized feature of transaction_count.
       - feature_name: ${resources.features.transaction_count.full_name}
         offline_store_config: # As in Step 3.
         cron_schedule_trigger:
           mode: DERIVED
       # Batch online materialized feature of transaction_count.
       - feature_name: ${resources.features.transaction_count.full_name}
         online_store_config:
           online_store_name: ${var.online_store}
           catalog_name: ${var.catalog}
           schema_name: ${var.schema}
-          table_name_prefix: transactions_online
+          table_name_prefix: transactions_online_v2
         cron_schedule_trigger:
           mode: DERIVED
       # Batch offline materialized feature of transaction_count_30d.
       - feature_name: ${resources.features.transaction_count_30d.full_name}
         offline_store_config: # As in Step 3.
         cron_schedule_trigger:
           mode: DERIVED
       # Batch online materialized feature of transaction_count_30d.
       - feature_name: ${resources.features.transaction_count_30d.full_name}
         online_store_config:
           online_store_name: ${var.online_store}
           catalog_name: ${var.catalog}
           schema_name: ${var.schema}
-          table_name_prefix: transactions_online
+          table_name_prefix: transactions_online_v2
         cron_schedule_trigger:
           mode: DERIVED

Python

 resources.add_materialization_set(
     'transactions',
     MaterializationSet(
         materialized_features=[
             # Batch offline materialized feature of transaction_count.
             MaterializedFeature(...),  # As in Step 3.
             # Batch online materialized feature of transaction_count.
             MaterializedFeature(
                 feature_name='${resources.features.transaction_count.full_name}',
                 online_store_config=OnlineStoreConfig(
                     online_store_name='${var.online_store}',
                     catalog_name='${var.catalog}',
                     schema_name='${var.schema}',
-                    table_name_prefix='transactions_online',
+                    table_name_prefix='transactions_online_v2',
                 ),
                 cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
             ),
             # Batch offline materialized feature of transaction_count_30d.
             MaterializedFeature(...),  # As in Step 3.
             # Batch online materialized feature of transaction_count_30d.
             MaterializedFeature(
                 feature_name='${resources.features.transaction_count_30d.full_name}',
                 online_store_config=OnlineStoreConfig(
                     online_store_name='${var.online_store}',
                     catalog_name='${var.catalog}',
                     schema_name='${var.schema}',
-                    table_name_prefix='transactions_online',
+                    table_name_prefix='transactions_online_v2',
                 ),
                 cron_schedule_trigger=CronSchedule(mode=CronScheduleMode.DERIVED),
             ),
         ]
     ),
 )

databricks bundle plan meldet eine Neuerstellung des Sets, sodass auch die beiden offline materialisierten Features fallen gelassen und neu berechnet werden:

recreate materialization_sets.transactions

Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged

Materialisierte Merkmale zu einem bestehenden Set hinzufügen

Das Hinzufügen eines materialisierten Merkmals zu einer bereits eingesetzten Materialisierungsmenge ersetzt die Menge, sodass jedes materialisierte Merkmal neu berechnet wird. Siehe Änderung eines Materialisierungssets.

Das Folgende nimmt die Menge transactions nach der Entfernung aller materialisierten Funktionen der Feature View transaction_count_30d in Removing of all that materialized features of a Feature View und fügt die materialisierten Features der Feature View transaction_count_30d wieder hinzu:

YAML

 materialization_sets:
   transactions:
     materialized_features:
       # Batch offline materialized feature of transaction_count.
       - feature_name: ${resources.features.transaction_count.full_name}
         offline_store_config: # As in Step 3.
         cron_schedule_trigger:
           mode: DERIVED
       # Batch online materialized feature of transaction_count.
       - feature_name: ${resources.features.transaction_count.full_name}
         online_store_config: # As in Step 3.
         cron_schedule_trigger:
           mode: DERIVED
+      # Batch offline materialized feature of transaction_count_30d.
+      - feature_name: ${resources.features.transaction_count_30d.full_name}
+        offline_store_config: # As in Step 3.
+        cron_schedule_trigger:
+          mode: DERIVED
+      # Batch online materialized feature of transaction_count_30d.
+      - feature_name: ${resources.features.transaction_count_30d.full_name}
+        online_store_config: # As in Step 3.
+        cron_schedule_trigger:
+          mode: DERIVED

Python

 resources.add_materialization_set(
     'transactions',
     MaterializationSet(
         materialized_features=[
             # Batch offline materialized feature of transaction_count.
             MaterializedFeature(...),  # As in Step 3.
             # Batch online materialized feature of transaction_count.
             MaterializedFeature(...),  # As in Step 3.
+            # Batch offline materialized feature of transaction_count_30d.
+            MaterializedFeature(...),  # As in Step 3.
+            # Batch online materialized feature of transaction_count_30d.
+            MaterializedFeature(...),  # As in Step 3.
         ]
     ),
 )

databricks bundle plan warnt vor jedem hinzugefügten materialisierten Feature und meldet eine Neuerstellung:

Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_30d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed
Warn: planning resources.materialization_sets.transactions: the member for feature "main.features_demo.transaction_count_30d" is not in the deployed set, and members cannot be added to an existing set, so the whole set will be recreated: every member is dropped and recomputed
recreate materialization_sets.transactions

Plan: 1 to add, 0 to change, 1 to delete, 6 unchanged

databricks bundle deploy bittet um eine Bestätigung, bevor das Set neu erstellt wird:

This action will result in the deletion or recreation of the following materialization sets.
Every materialized feature in a recreated set is dropped and recomputed from scratch, including
the members whose configuration did not change:
  recreate resources.materialization_sets.transactions

Entfernen einiger der materialisierten Features einer Feature View

Das Entfernen einiger, aber nicht aller materialisierten Features einer Feature View aus einem Materialisierungsset wird abgelehnt. Siehe Änderung eines Materialisierungssets.

Das Folgende nimmt das in amount_sum für Feature View amounts definierte Set , das ein Sägezahnfenster besitzt, und entfernt nur sein batch-offline materialisiertes Feature:

YAML

 materialization_sets:
   amounts:
     materialized_features:
-      # Batch offline materialized feature.
-      - feature_name: ${resources.features.amount_sum.full_name}
-        offline_store_config: # As in Step 5.
-        cron_schedule_trigger:
-          mode: DERIVED
       # Batch online materialized feature.
       - feature_name: ${resources.features.amount_sum.full_name}
         online_store_config: # As in Step 5.
         cron_schedule_trigger:
           mode: DERIVED
       # Streaming online materialized feature.
       - feature_name: ${resources.features.amount_sum.full_name}
         online_store_config: # As in Step 5.
         streaming_mode:
           mode: STREAMING_MODE_TYPE_RTM

Python

 resources.add_materialization_set(
     'amounts',
     MaterializationSet(
         materialized_features=[
-            # Batch offline materialized feature.
-            MaterializedFeature(...),  # As in Step 5.
             # Batch online materialized feature.
             MaterializedFeature(...),  # As in Step 5.
             # Streaming online materialized feature.
             MaterializedFeature(...),  # As in Step 5.
         ]
     ),
 )

Die Bearbeitung entfernt die Batch-Offline-Materialisierungsfunktion von amount_sum, und diese Löschung löscht auch die beiden anderen materialisierten Funktionen derselben Feature View, die die Bearbeitung nicht verlangt. Die Bereitstellung wird abgelehnt:

Error: cannot update resources.materialization_sets.amounts: updating id=1234567890abcdef1234567890abcdef: Deleting materialized features '11111111111111111111111111111111' of feature 'main.features_demo.amount_sum_3d' also deletes materialized features '22222222222222222222222222222222', '33333333333333333333333333333333', which the request does not delete. Delete the unrequested materialized features as well. (400 INVALID_PARAMETER_VALUE)

Schritt 10: Aufräumen

Materialisierungspipelines laufen weiterhin nach ihrem konfigurierten Zeitplan, bis das Set gelöscht wird. Baue das Bundle ab, wenn du fertig bist:

databricks bundle destroy

Dadurch werden die Materialisierungssets und die in jeder im Bundle enthaltenen Datei deklarierten Feature Views gelöscht. Die Tabellen, Pipelines und Jobs hinter einem materialisierten Feature werden durch einen Hintergrundprozess entfernt, nachdem das zuletzt materialisierte Feature, das sie geteilt hat, verschwunden ist, sodass es eine kurze Verzögerung gibt, bevor die zugehörigen Kosten enden. Nur der Nutzer, der ein materialisiertes Feature erstellt hat, kann es löschen, also führen Sie databricks bundle destroy mit derselben Identität aus, die das Bundle bereitgestellt hat. Siehe delete_materialized_feature().

Informationen dazu, welche Materialisierungskosten anfallen und wie sie zugeordnet werden, finden Sie unter Feature Store-Kostenmanagement.

Einschränkungen

  • Ein Stream ist keine Bundle-Ressource. Erstellen Sie es außerhalb des Bundles und referenzieren Sie es über seinen Namen.
  • Eine FeatureSpec ist keine Bundle-Ressource. Erstellen Sie eine Feature-Ansicht mit der Python-API, um Features online bereitzustellen. Siehe Feature-Ansichten bereitstellen.
  • Das Hinzufügen eines materialisierten Merkmals zu einer bestehenden Materialisierungsmenge erschafft die Menge neu, sodass jedes materialisierte Merkmal darin neu berechnet wird.
  • Eine Feature View auf einem request_source oder feature_view_source, oder eine, die eine custom_udf Funktion verwendet, kann nicht materialisiert werden. Siehe Materialisieren von Featureansichten.

Nächste Schritte