Lernprogramm zum verwalteten Featurespeicher 1: Entwickeln und Registrieren eines Featuresatzes

In dieser Lernprogrammreihe erfahren Sie, wie Sie den verwalteten Featurespeicher verwenden, um Azure Machine Learning-Features zu ermitteln, zu erstellen und zu operationalisieren. Features integrieren nahtlos die Prototyp-, Schulungs- und Operationalisierungsphasen des Machine Learning-Lebenszyklus.

In der Prototypphase experimentieren Sie mit verschiedenen Features, und in der Operationalisierungsphase stellen Sie Modelle bereit, die Folgeschritte verwenden, um Featuredaten nachzuschlagen. Funktionen dienen als Bindegewebe im Produktlebenszyklus.

Sie verwenden einen Azure Machine Learning-Projektarbeitsbereich, um Schlussfolgerungsmodelle mithilfe von Features aus Featurespeichern zu trainieren. Viele Projektarbeitsbereiche können denselben Feature Store gemeinsam nutzen und wiederverwenden. Weitere Informationen zum verwalteten Featurespeicher finden Sie unter "Was ist verwalteter Featurespeicher " und "Grundlegendes zu Entitäten der obersten Ebene im verwalteten Featurespeicher".

Voraussetzungen

• Ein Azure Machine Learning-Arbeitsbereich. Weitere Informationen zur Arbeitsbereicherstellung finden Sie in der Schnellstartanleitung: Erstellen von Arbeitsbereichsressourcen.
• Besitzerrolle in der Ressourcengruppe, in der der Featurespeicher erstellt wird.

SDK- und CLI-Tutorial-Tracks oder Nur-SDK-Tutorial-Tracks

In dieser Lernprogrammreihe wird ein Azure Machine Learning Spark-Notizbuch für die Entwicklung verwendet. Sie können je nach Bedarf zwischen zwei Titeln wählen, um die Lernprogrammreihe abzuschließen.

• Das SDK + CLI-Track verwendet das Python SDK für die Entwicklung und Tests von Featuregruppen und verwendet Azure CLI zum Erstellen, Lesen, Aktualisieren und Löschen (CRUD)-Vorgängen. Dieser Pfad ist nützlich für kontinuierliche Integrations- und Bereitstellungsprozesse (CI/CD) oder GitOps-Ansätze, die CLI und YAML verwenden.

• Beim reinen SDK-Ansatz werden nur Python-SDKs verwendet. Dieser Kurs bietet ausschließlich Python-basierte Entwicklung und Bereitstellung.

Sie wählen einen Titel aus, indem Sie das Notizbuch entweder im cli_and_sdk - oder sdk_only Ordner Ihres geklonten Notizbuchs öffnen. Folgen Sie den Anweisungen auf der entsprechenden Registerkarte in den Lernprogrammen.

Lernprogramm 1: Entwickeln und Registrieren eines Featuresatzes

In diesem ersten Lernprogramm wird erläutert, wie man eine Spezifikation eines Merkmalsatzes mit benutzerdefinierten Transformationen erstellt. Anschließend verwenden Sie diesen Featuresatz, um Schulungsdaten zu generieren, Materialisierung zu ermöglichen und einen Rückfüllvorgang durchzuführen. Hier erfahren Sie, wie Sie:

Klonen des Notizbuchs

1. Wählen Sie in Azure Machine Learning Studio Notizbücher im linken Navigationsmenü und dann die Registerkarte "Beispiele " auf der Seite " Notizbücher " aus.

2. Erweitern Sie die SDK v2>sdk>python-Ordner, klicken Sie mit der rechten Maustaste auf den Featurestore_sample-Ordner, und wählen Sie Klonen aus.

   

3. Navigieren Sie zum Bereich Zielverzeichnis auswählen und überprüfen Sie, ob Benutzer><your_username>>featurestore_sample angezeigt wird, und wählen Sie dann Klonen aus. Das featurestore_sample wird in Ihr Arbeitsbereichsbenutzerverzeichnis geklont.

4. Navigieren Sie zu Ihrem geklonten Notebook auf der Registerkarte Dateien auf der Seite Notebook und erweitern Sie Benutzer><your_username>>featurestore_sample>Projekt>env.

5. Klicken Sie mit der rechten Maustaste auf die conda.yml Datei, und wählen Sie "Herunterladen " aus, um sie auf Ihren Computer herunterzuladen, damit Sie sie später in die Serverumgebung hochladen können.

   

Vorbereiten und Starten des Notizbuchs

1. Erweitern Sie im linken Bereich auf der Registerkarte Dateienfeaturestore_sample>Notebooks>SDK_und_CLI oder sdk_only, je nachdem, welchen Track Sie ausführen möchten.

2. Öffnen Sie das erste Kapitel des Lernprogramms, indem Sie es auswählen.

3. Wählen Sie im oberen rechten Bereich der Seite " Notizbuch " den Dropdownpfeil neben "Compute" aus, und wählen Sie "Serverless Spark Compute " Verfügbar" aus. Es kann eine oder zwei Minuten dauern, bis die Berechnung angefügt wird.

4. Wählen Sie auf der oberen Leiste oberhalb der Notizbuchdatei " Sitzung konfigurieren" aus.

   

5. Wählen Sie auf dem Bildschirm " Sitzung konfigurieren " die Option "Python-Pakete " im linken Bereich aus.

6. Wählen Sie "Conda-Datei hochladen" aus, und navigieren Sie unter " Conda-Datei auswählen" zu der conda.yml Datei, die Sie heruntergeladen haben.

7. Wählen Sie optional Einstellungen im linken Bereich aus und erhöhen Sie die Dauer der Sitzungs-Timeout, um zu verhindern, dass die serverlose Spark-Startzeit abläuft.

8. Wählen Sie Anwenden.

   

Starten des Notizbuchs

Erstellen eines minimalen Feature Stores

1. Legen Sie Feature Store-Parameter fest, z. B. Name, Speicherort und andere Werte. Geben Sie einen <FEATURESTORE_NAME> an und führen Sie die Zelle aus.

   # We use the subscription, resource group, region of this active project workspace.
   # You can optionally replace them to create the resources in a different subsciprtion/resource group, or use existing resources.
   import os
   
   featurestore_name = "<FEATURESTORE_NAME>"
   featurestore_location = "eastus"
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

2. Erstellen Sie den Feature Store.

   • SDK und CLI-Ansatz
   • SDK-Ansatz

   !az ml feature-store create --subscription $featurestore_subscription_id --resource-group $featurestore_resource_group_name --location $featurestore_location --name $featurestore_name

3. Initialisieren Sie einen Feature Store Core SDK-Client für Azure Machine Learning. Der Client wird verwendet, um Features zu entwickeln und zu nutzen.

   # feature store client
   from azureml.featurestore import FeatureStoreClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   featurestore = FeatureStoreClient(
       credential=AzureMLOnBehalfOfCredential(),
       subscription_id=featurestore_subscription_id,
       resource_group_name=featurestore_resource_group_name,
       name=featurestore_name,
   )

4. Gewähren Sie Ihrer Benutzeridentität die AzureML Data Scientist-Rolle im Feature Store. Rufen Sie Ihren Microsoft Entra-Objekt-ID-Wert aus dem Azure-Portal ab, wie unter "Suchen der Benutzerobjekt-ID" beschrieben.

5. Führen Sie die folgende Zelle aus, um Ihrer Benutzeridentität die AzureML Data Scientist-Rolle zuzuweisen, damit sie Ressourcen im Featurespeicher-Arbeitsbereich erstellen kann. Ersetzen Sie den <USER_AAD_OBJECTID> Platzhalter durch Ihre Microsoft Entra-Objekt-ID. Es kann einige Zeit dauern, bis sich die Genehmigungen durchsetzen.

   your_aad_objectid = "<USER_AAD_OBJECTID>"
   
   !az role assignment create --role "AzureML Data Scientist" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $feature_store_arm_id

   Weitere Informationen zur Zugriffssteuerung finden Sie unter Verwalten der Zugriffssteuerung für den verwalteten Featurespeicher.

Erstellen eines Prototyps und Entwicklung eines Featuresatzes

Dieses Notizbuch verwendet Beispieldaten, die in einem öffentlich zugänglichen BLOB-Container gehostet werden, den Sie in Spark nur über einen wasbs Treiber lesen können. Wenn Sie Featuresätze mithilfe Ihrer eigenen Quelldaten erstellen, hosten Sie diese in einem Azure Data Lake Storage-Konto, und verwenden Sie einen abfss Treiber im Datenpfad.

Erkunden der Transaktionsquelldaten

Erstellen Sie einen Featuresatz mit dem Namen transactions, der Merkmale basierend auf Rollfensteraggregaten enthält.

# remove the "." in the roor directory path as we need to generate absolute path to read from spark
transactions_source_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet"
transactions_src_df = spark.read.parquet(transactions_source_data_path)

display(transactions_src_df.head(5))
# Note: display(training_df.head(5)) displays the timestamp column in a different format. You can can call transactions_src_df.show() to see correctly formatted value

Lokal entwickeln Sie den Featuresatz

Eine Featuresatzspezifikation ist eine eigenständige Definition eines Featuresatzes, die Sie lokal entwickeln und testen können. Erstellen Sie die folgenden Aggregatfunktionen für rollierende Fenster:

• transactions three-day count
• transactions amount three-day avg
• transactions amount three-day sum
• transactions seven-day count
• transactions amount seven-day avg
• transactions amount seven-day sum

from azureml.featurestore import create_feature_set_spec
from azureml.featurestore.contracts import (
    DateTimeOffset,
    TransformationCode,
    Column,
    ColumnType,
    SourceType,
    TimestampColumn,
)
from azureml.featurestore.feature_source import ParquetFeatureSource

transactions_featureset_code_path = (
    root_dir + "/featurestore/featuresets/transactions/transformation_code"
)

transactions_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
        source_delay=DateTimeOffset(days=0, hours=0, minutes=20),
    ),
    feature_transformation=TransformationCode(
        path=transactions_featureset_code_path,
        transformer_class="transaction_transform.TransactionFeatureTransformer",
    ),
    index_columns=[Column(name="accountID", type=ColumnType.string)],
    source_lookback=DateTimeOffset(days=7, hours=0, minutes=0),
    temporal_join_lookback=DateTimeOffset(days=1, hours=0, minutes=0),
    infer_schema=True,
)

Überprüfen Sie die Codedatei für die Featuretransformation: featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Beachten Sie die für die Features definierte rollierende Aggregation. Diese Datei ist ein Spark-Transformator. Weitere Informationen zum Featuresatz und zu Transformationen finden Sie unter Was ist der verwaltete Featurespeicher?

Exportieren als Featuresatzspezifikation

Um die Featuresatzspezifikation beim Featurespeicher zu registrieren, speichern Sie diese Spezifikation an einem angegebenen Speicherort und Format, das die Quellcodeverwaltung unterstützt.

import os

# Create a new folder to dump the feature set specification.
transactions_featureset_spec_folder = (
    root_dir + "/featurestore/featuresets/transactions/spec"
)

# Check if the folder exists, create one if it does not exist.
if not os.path.exists(transactions_featureset_spec_folder):
    os.makedirs(transactions_featureset_spec_folder)

transactions_featureset_spec.dump(transactions_featureset_spec_folder, overwrite=True)

Um die featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml-Spezifikation anzuzeigen, öffnen Sie in der Dateistruktur die generierte transactions Featuresatz-Spezifikation. Die Spezifikation enthält die folgenden Elemente:

• source: ein Verweis auf eine Speicherressource. In diesem Fall handelt es sich um eine Parquet-Datei in einer Blobspeicherressource.
• features: eine Liste der Features und ihrer Datentypen. Wenn Sie Transformationscode bereitstellen, muss der Code einen DataFrame zurückgeben, der den Features und Datentypen entspricht.
• index_columns: die Joinschlüssel, die für den Zugriff auf Werte aus dem Featureset erforderlich sind.

Registrieren einer Feature Store-Entität

Entitäten helfen beim Erzwingen der bewährten Methode für die Verwendung derselben Verknüpfungsschlüsseldefinition über Featuresätze hinweg, die dieselben logischen Entitäten verwenden. Beispiele für Entitäten umfassen accounts und customers. Entitäten werden in der Regel einmal erstellt und dann in Featuresätzen wiederverwendet. Weitere Informationen finden Sie unter „Grundlegendes zu Entitäten der obersten Ebene im verwalteten Featurespeicher“.

account_entity_path = root_dir + "/featurestore/entities/account.yaml"
!az ml feature-store-entity create --file $account_entity_path --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

Registrierung des Featuresatzes im Feature-Store

Der folgende Code registriert im Featurespeicher eine Featuresatz-Ressource. Sie können diese Ressource dann wiederverwenden und problemlos freigeben. Die Registrierung einer Featuresatzressource bietet verwaltete Funktionen, einschließlich Versionsverwaltung und Materialisierung. In späteren Lernprogrammen dieser Reihe werden verwaltete Funktionen behandelt.

account_featureset_path = (
    root_dir + "/featurestore/featuresets/transactions/featureset_asset.yaml"
)
!az ml feature-set create --file $account_featureset_path --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

from azure.ai.ml.entities import FeatureSetSpecification

transaction_fset_config = FeatureSet(
    name="transactions",
    version="1",
    description="7-day and 3-day rolling aggregation of transactions featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=transactions_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

poller = fs_client.feature_sets.begin_create_or_update(transaction_fset_config)
print(poller.result())

Erkunden der Benutzeroberfläche des Feature Stores

Die Erstellung und Aktualisierung von Feature Store-Ressourcen können nur über das SDK und die CLI erfolgen. Sie können die Benutzeroberfläche für maschinelles Lernen verwenden, um den Featurespeicher zu durchsuchen.

1. Öffnen Sie die globale Landing Page von Azure Machine Learning.
2. Wählen Sie im linken Bereich Feature Stores aus.
3. Wählen Sie in der Liste der barrierefreien Featurespeicher den Featurespeicher aus, den Sie zuvor in diesem Lernprogramm erstellt haben.

Zuweisen der Rolle "Storage Blob Data Reader"

Die Rolle Storage Blob Data Reader muss Ihrem Benutzerkonto zugewiesen werden, um sicherzustellen, dass das Benutzerkonto materialisierte Featuredaten aus dem Offline-Materialisierungsspeicher lesen kann.

Informationen über den Offline-Materialisierungsspeicher erhalten Sie auf der Seite Übersicht auf der Featurespeicher-Benutzeroberfläche. Die Werte für das Speicherkonto <SUBSCRIPTION_ID>, das Speicherkonto <RESOURCE_GROUP> und den Offline-Materialisierungsspeicher <STORAGE_ACCOUNT_NAME> befinden sich auf der Offline-Materialisierungsspeicherkarte.

storage_subscription_id = "<SUBSCRIPTION_ID>"
storage_resource_group_name = "<RESOURCE_GROUP>"
storage_account_name = "<STORAGE_ACCOUNT_NAME>"

# Set the ADLS Gen2 storage account ARM ID
gen2_storage_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}".format(
    sub_id=storage_subscription_id,
    rg=storage_resource_group_name,
    account=storage_account_name,
)

print(gen2_storage_arm_id)

!az role assignment create --role "Storage Blob Data Reader" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $gen2_storage_arm_id

Weitere Informationen zur Zugriffssteuerung finden Sie unter Verwalten der Zugriffssteuerung für den verwalteten Featurespeicher.

Generieren eines Schulungsdatenframes

Generieren Sie ein Schulungsdaten-DataFrame mithilfe des registrierten Merkmalsatzes.

1. Laden von Beobachtungsdaten, die während des Ereignisses selbst erfasst wurden.

   Beobachtungsdaten umfassen in der Regel die Kerndaten, die für Schulungen und Ableitungen verwendet werden, die mit den Featuredaten verknüpft werden, um die vollständige Schulungsdatenressource zu erstellen. Die folgenden Daten enthalten Kerntransaktionsdaten, einschließlich Transaktions-ID, Konto-ID und Transaktionsbetragswerte. Da Sie die Daten für die Schulung verwenden, verfügt sie auch über eine angefügte Zielvariable is_fraud.

   observation_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"
   observation_data_df = spark.read.parquet(observation_data_path)
   obs_data_timestamp_column = "timestamp"
   
   display(observation_data_df)
   # Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

2. Rufen Sie den registrierten Featuresatz ab, und listen Sie die zugehörigen Features auf.

   # Look up the featureset by providing a name and a version.
   transactions_featureset = featurestore.feature_sets.get("transactions", "1")
   # List its features.
   transactions_featureset.features

   # Print sample values.
   display(transactions_featureset.to_spark_dataframe().head(5))

3. Wählen Sie die Features aus, die Teil der Schulungsdaten werden sollen, und verwenden Sie das Featurespeicher-SDK, um die Schulungsdaten selbst zu generieren. Ein Zeitpunktjoin fügt die Features an die Trainingsdaten an.

   from azureml.featurestore import get_offline_features
   
   # You can select features in pythonic way.
   features = [
       transactions_featureset.get_feature("transaction_amount_7d_sum"),
       transactions_featureset.get_feature("transaction_amount_7d_avg"),
   ]
   
   # You can also specify features in string form: featureset:version:feature.
   more_features = [
       f"transactions:1:transaction_3d_count",
       f"transactions:1:transaction_amount_3d_avg",
   ]
   
   more_features = featurestore.resolve_feature_uri(more_features)
   features.extend(more_features)
   
   # Generate training dataframe by using feature data and observation data.
   training_df = get_offline_features(
       features=features,
       observation_data=observation_data_df,
       timestamp_column=obs_data_timestamp_column,
   )
   
   # Ignore the message that says feature set is not materialized (materialization is optional). We will enable materialization in the subsequent part of the tutorial.
   display(training_df)
   # Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

Aktivieren der Offlinematerialisierung

Die Materialisierung berechnet die Featurewerte für ein Featurefenster und speichert diese Werte in einem Materialisierungsspeicher. Alle Merkmalsabfragen können dann diese Werte aus dem Materialisierungsspeicher verwenden.

Ohne Materialisierung wendet eine Featuresatzabfrage Transformationen auf die Quelle automatisch an und berechnet die Features, bevor die Werte zurückgegeben werden. Dieser Vorgang funktioniert gut für die Phase der Prototyperstellung. Für Schulungs- und Ableitungsvorgänge in einer Produktionsumgebung bietet die Materialisierung der Features jedoch eine höhere Zuverlässigkeit und Verfügbarkeit.

Der standardmäßige Blobspeicher für den Featurespeicher ist ein ADLS-Container (Azure Data Lake Storage). Ein Feature Store wird immer mit einem Offline-Materialisierungsspeicher und einer benutzerseitig zugewiesenen verwalteten Identität (UAI) erstellt.

Wenn ein Featurespeicher mit den Standardwerten für die Parameter offline_store=None und materialization_identity=None erstellt wird, führt das System das folgende Setup durch:

1. Erstellt einen ADLS-Container als Offlinespeicher.
2. Erstellt eine UAI und weist sie dem Featurespeicher als Materialisierungsidentität zu.
3. Weist der UAI im Offline-Speicher die erforderlichen rollenbasierten Zugriffssteuerungen (RBAC) zu.

Optional können Sie einen vorhandenen ADLS-Container als Offlinespeicher verwenden, indem Sie den offline_store Parameter definieren. Nur ADLS-Container werden für Offline-Materialisierungsspeicher unterstützt.

Optional können Sie eine vorhandene UAI bereitstellen, indem Sie einen materialization_identity Parameter definieren. Die erforderlichen RBAC-Berechtigungen werden der UAI auf dem Offline-Speicher während der Feature-Store-Erstellung zugewiesen.

Das folgende Codebeispiel zeigt die Erstellung eines Feature Stores mit benutzerdefinierten offline_store und materialization_identity Parametern.

   import os
   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   from azure.ai.ml.entities import (
      ManagedIdentityConfiguration,
      FeatureStore,
      MaterializationStore,
   )
   from azure.mgmt.msi import ManagedServiceIdentityClient

   # Get an existing offline store
   storage_subscription_id = "<OFFLINE_STORAGE_SUBSCRIPTION_ID>"
   storage_resource_group_name = "<OFFLINE_STORAGE_RESOURCE_GROUP>"
   storage_account_name = "<OFFLINE_STORAGE_ACCOUNT_NAME>"
   storage_file_system_name = "<OFFLINE_STORAGE_CONTAINER_NAME>"

   # Get ADLS container ARM ID
   gen2_container_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}/blobServices/default/containers/{container}".format(
      sub_id=storage_subscription_id,
      rg=storage_resource_group_name,
      account=storage_account_name,
      container=storage_file_system_name,
   )

   offline_store = MaterializationStore(
      type="azure_data_lake_gen2",
      target=gen2_container_arm_id,
   )

   # Get an existing UAI
   uai_subscription_id = "<UAI_SUBSCRIPTION_ID>"
   uai_resource_group_name = "<UAI_RESOURCE_GROUP>"
   uai_name = "<FEATURE_STORE_UAI_NAME>"

   msi_client = ManagedServiceIdentityClient(
      AzureMLOnBehalfOfCredential(), uai_subscription_id
   )

   managed_identity = msi_client.user_assigned_identities.get(
      uai_resource_group_name, uai_name
   )

   # Get UAI information
   uai_principal_id = managed_identity.principal_id
   uai_client_id = managed_identity.client_id
   uai_arm_id = managed_identity.id

   materialization_identity1 = ManagedIdentityConfiguration(
      client_id=uai_client_id, principal_id=uai_principal_id, resource_id=uai_arm_id
   )

   # Create a feature store
   featurestore_name = "<FEATURE_STORE_NAME>"
   featurestore_location = "<AZURE_REGION>"
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

   ml_client = MLClient(
      AzureMLOnBehalfOfCredential(),
      subscription_id=featurestore_subscription_id,
      resource_group_name=featurestore_resource_group_name,
   )

   # Use existing ADLS Gen2 container and UAI
   fs = FeatureStore(
      name=featurestore_name,
      location=featurestore_location,
      offline_store=offline_store,
      materialization_identity=materialization_identity1,
   )

   fs_poller = ml_client.feature_stores.begin_update(fs)

   print(fs_poller.result()) 

Nachdem Sie die Featuresatzmaterialisierung für den Transaktionsfeaturesatz festgelegt haben, können Sie einen Abgleich ausführen. Sie können auch wiederkehrende Materialisierungsaufträge planen. Weitere Informationen finden Sie im dritten Lernprogramm in dieser Reihe: Aktivieren der wiederkehrenden Materialisierung und Ausführung von Batch-Ableitungen.

Festlegen von spark.sql.shuffle.partitions in der YAML-Datei

Die Spark-Konfiguration spark.sql.shuffle.partitions ist ein optionaler Parameter, der die Anzahl der pro Tag generierten Parquet-Dateien beeinflussen kann, wenn der Satz im Offlinespeicher materialisiert wird. Der Standardwert dieses Parameters ist 200.

Vermeiden Sie als bewährte Methode die Erzeugung vieler kleiner Parquet-Dateien. Wenn das Abrufen von Features im Offlinespeicher nach der Materialisierung des Satzes verlangsamt wird, öffnen Sie im Offlinespeicher den entsprechenden Ordner. Überprüfen Sie, ob das Problem durch zu viele kleine Parquet-Dateien pro Tag verursacht wird, und passen Sie den Wert dieses Parameters entsprechend der Größe der Featuredaten an.

transaction_asset_mat_yaml = (
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

!az ml feature-set update --file $transaction_asset_mat_yaml --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

from azure.ai.ml.entities import (
    MaterializationSettings,
    MaterializationComputeResource,
)

transactions_fset_config = fs_client._featuresets.get(name="transactions", version="1")

transactions_fset_config.materialization_settings = MaterializationSettings(
    offline_enabled=True,
    resource=MaterializationComputeResource(instance_type="standard_e8s_v3"),
    spark_configuration={
        "spark.driver.cores": 4,
        "spark.driver.memory": "36g",
        "spark.executor.cores": 4,
        "spark.executor.memory": "36g",
        "spark.executor.instances": 2,
        "spark.sql.shuffle.partitions": 1,
    },
    schedule=None,
)

fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)
print(fs_poller.result())

## uncomment to run
transactions_fset_config.dump(
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

Abgleichen von Daten für den Transaktionsfeaturesatz

Die Materialisierung berechnet die Featurewerte für ein Featurefenster und speichert diese berechneten Werte in einem Materialisierungsspeicher. Die Featurematerialisierung erhöht die Zuverlässigkeit und Verfügbarkeit der berechneten Werte. Alle Featureabfragen verwenden nun die Werte aus dem Materialisierungsspeicher. In diesem Schritt wird ein einmaliges Backfill für ein Feature-Fenster von 18 Monaten durchgeführt.

Die folgende Codezelle materialisiert Daten nach dem aktuellen Status None oder Incomplete für das definierte Featurefenster. Sie können eine Liste mit mehr als einem Datenstatus angeben, z. B. ["None", "Incomplete"], in einem einzigen Backfill-Job.

feature_window_start_time = "2022-01-01T00:00.000Z"
feature_window_end_time = "2023-06-30T00:00.000Z"

!az ml feature-set backfill --name transactions --version 1 --by-data-status "['None', 'Incomplete']" --feature-window-start-time $feature_window_start_time --feature-window-end-time $feature_window_end_time --feature-store-name $featurestore_name --resource-group $featurestore_resource_group_name

from datetime import datetime
from azure.ai.ml.entities import DataAvailabilityStatus

st = datetime(2022, 1, 1, 0, 0, 0, 0)
et = datetime(2023, 6, 30, 0, 0, 0, 0)

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version="1",
    feature_window_start_time=st,
    feature_window_end_time=et,
    data_status=[DataAvailabilityStatus.NONE],
)
print(poller.result().job_ids)

# Get the job URL, and stream the job logs.
fs_client.jobs.stream(poller.result().job_ids[0])

Drucken Sie Beispieldaten aus dem Feature-Set. Die Ausgabeinformationen zeigen, dass die Daten aus dem Materialisierungsspeicher abgerufen wurden. Die get_offline_features() Methode ruft die Schulungs- und Ableitungsdaten ab und verwendet standardmäßig den Materialisierungsspeicher.

# Look up the feature set by providing a name and a version and display few records.
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
display(transactions_featureset.to_spark_dataframe().head(5))

Weitere Untersuchung der Offline-Materialisierung von Merkmalen

Sie können den Materialisierungsstatus eines Feature-Sets in der Benutzeroberfläche Materialisierungsaufträge anzeigen.

1. Öffnen Sie die globale Landing Page von Azure Machine Learning.

2. Wählen Sie im linken Bereich Feature Stores aus.

3. Wählen Sie in der Liste der verfügbaren Featurespeicher den Featurespeicher aus, für den Sie die Rückfüllung durchgeführt haben.

4. Wählen Sie die Registerkarte " Materialisierungsaufträge " aus.

   

Der Datenmaterialisierungsstatus kann wie folgt sein:

• Vollständig (grün)
• Unvollständig (rot)
• Anhängig (blau)
• Keiner (grau)

Ein Datenintervall stellt einen zusammenhängenden Teil von Daten mit demselben Datenmaterialisierungsstatus dar. Der frühere Snapshot hat zum Beispiel 16 Datenintervalle im Offline-Materialisierungsspeicher. Die Daten können maximal 2.000 Datenintervalle aufweisen. Wenn Ihre Daten über 2.000 Datenintervalle enthalten, erstellen Sie eine neue Feature-Set-Version.

Während des Nachfüllprozesses wird für jedes Datenintervall, das in das definierte Featurefenster fällt, ein neuer Materialisierungsauftrag eingereicht. Es wird kein Auftrag gesendet, wenn bereits ein Materialisierungsauftrag aussteht oder für ein Datenintervall ausgeführt wird, das nicht abgeglichen wird.

Sie können einen fehlgeschlagenen Materialisierungsauftrag wiederholen.

az ml feature-set backfill --by-job-id <JOB_ID_OF_FAILED_MATERIALIZATION_JOB> --name <FEATURE_SET_NAME> --version <VERSION>  --feature-store-name <FEATURE_STORE_NAME> --resource-group <RESOURCE_GROUP>

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version=version,
    job_id="<JOB_ID_OF_FAILED_MATERIALIZATION_JOB>",
)
print(poller.result().job_ids)

Aktualisieren eines Offline-Materialisierungsspeichers

Wenn ein Offlinematerialisierungsspeicher auf Featurespeicherebene aktualisiert werden muss, sollten alle Featuresätze im Featurespeicher die Offlinematerialisierung deaktiviert haben.

Wenn die Offline-Materialisierung für ein Featuresatzes deaktiviert ist, wird der Materialisierungsstatus der bereits im Offline-Materialisierungsspeicher materialisierten Daten zurückgesetzt. Durch das Zurücksetzen werden bereits materialisierte Daten unbrauchbar gemacht. Nach der Aktivierung der Offline-Materialisierung müssen Sie die Materialisierungsaufträge erneut einreichen.

Bereinigen

Das fünfte Lernprogramm in dieser Reihe, Entwickeln eines Featuresatzes mit einer benutzerdefinierten Quelle, beschreibt, wie die Ressourcen gelöscht werden.

Nächster Schritt

In diesem Lernprogramm wurden die Trainingsdaten mit Merkmalen aus dem Merkmalsspeicher erstellt, die Materialisierung in den Offline-Merkmalsspeicher aktiviert und ein Abgleich durchgeführt.

Das nächste Lernprogramm in der Reihe, Experimentieren und Trainieren von Modellen mithilfe von Features, zeigt Ihnen, wie Sie Modellschulungen mit diesen Features ausführen.

Verwandte Inhalte

• Was ist ein verwalteter Featurespeicher?
• Verstehen von Entitäten der obersten Ebene im verwalteten Feature Store.
• Verwalten der Zugriffssteuerung für den verwalteten Featurespeicher.
• Problembehandlung für den verwalteten Funktionsspeicher.
• CLI (v2) YAML-Schemas