Tutorial 6: Netzwerkisolation mit Featurespeicher

Artikel
09/04/2024

Mit dem verwalteten Feature Store von Azure Machine Learning können Sie Features entdecken, erstellen und operationalisieren. Features fungieren im Lebenszyklus des maschinellen Lernens als Bindeglieder. Dieser beginnt mit der Phase für die Prototyperstellung, in der Sie mit verschiedenen Features experimentieren. Dieser Lebenszyklus wird mit der Operationalisierungsphase fortgesetzt, in der Sie Modelle bereitstellen und Rückschlussschritte nach Featuredaten suchen. Weitere Informationen zu Featurespeichern finden Sie im Dokument zu den Featurespeicher-Konzepten.

In diesem Tutorial wird beschrieben, wie Sie den sicheren Eingang über einen privaten Endpunkt und den sicheren Ausgang über ein verwaltetes virtuelles Netzwerk konfigurieren.

In Teil 1 dieser Tutorialreihe wurde gezeigt, wie Sie eine Featuresatzspezifikation mit benutzerdefinierten Transformationen erstellen und diesen Featuresatz verwenden, um Trainingsdaten zu generieren. In Teil 2 der Serie wurde gezeigt, wie man die Materialisierung aktiviert und ein Backfill durchführt. Außerdem wurde in Teil 2 gezeigt, wie man mit Merkmalen experimentiert, um die Modellleistung zu verbessern. In Teil 3 wurde gezeigt, wie ein Feature Store die Agilität der Experimentier- und Schulungsabläufe erhöht. In Teil 3 wurde auch beschrieben, wie man eine Batch-Inferenz durchführt. In Tutorial 4 wurde erläutert, wie der Featurespeicher für Anwendungsfälle für Online-/Echtzeitrückschlüsse verwendet wird. In Tutorial 5 wurde gezeigt, wie Sie einen Featuresatz mit einer benutzerdefinierten Datenquelle entwickeln. In Tutorial 6 wird Folgendes gezeigt:

Einrichten der erforderlichen Ressourcen für die Netzwerkisolation eines verwalteten Feature Store
Erstellen einer neuen Feature Store-Ressource
Einrichten des Feature Store, um Netzwerkisolationsszenarien zu unterstützen
Aktualisieren des Projektarbeitsbereichs (aktueller Arbeitsbereich), um Netzwerkisolationsszenarien zu unterstützen

Voraussetzungen

Hinweis

In diesem Tutorial wird ein Azure Machine Learning-Notebook mit serverlosem Spark Compute verwendet.

Ein Azure Machine Learning-Arbeitsbereich, für den ein verwaltetes virtuelles Netzwerk für serverlose Spark-Aufträge aktiviert ist
So konfigurieren Sie Ihren Projektarbeitsbereich
1. Erstellen Sie eine YAML-Datei mit dem Namen network.yml:
```
managed_network:
isolation_mode: allow_internet_outbound
```
2. Führen Sie die folgenden Befehle aus, um den Arbeitsbereich zu aktualisieren und das verwaltete virtuelle Netzwerk für serverlose Spark-Aufträge bereitzustellen:
```
az ml workspace update --file network.yml --resource-group my_resource_group --name
my_workspace_name
az ml workspace provision-network --resource-group my_resource_group --name my_workspace_name
--include-spark
```
Weitere Informationen finden Sie unter Konfigurieren für serverlose Spark-Aufträge.
Ihrem Benutzerkonto muss die Rolle Owner oder Contributor für die Ressourcengruppe zugewiesen sein, in der Sie den Feature Store erstellen. Ihr Benutzerkonto benötigt außerdem die Rolle User Access Administrator.

Wichtig

Legen Sie für Ihren Azure Machine Learning-Arbeitsbereich isolation_mode auf allow_internet_outbound fest. Dies ist der einzige unterstützte Netzwerkisolationsmodus. In diesem Tutorial wird gezeigt, wie Sie über private Endpunkte eine sichere Verbindung mit Quellen, dem Materialisierungsspeicher und Beobachtungsdaten herstellen.

Einrichten

In diesem Tutorial wird das Python Feature Store Core SDK (azureml-featurestore) verwendet. Für das Entwickeln und Testen von Featuresätzen wird nur das Python SDK verwendet. Die CLI wird für CRUD-Vorgänge (Create, Read, Update, Delete; Erstellen, Lesen, Aktualisieren, Löschen) in Feature Stores, Featuresätzen und Feature Store-Entitäten verwendet. Dies ist in CI/CD-Szenarien (Continuous Integration/Continuous Delivery) oder GitOps-Szenarien nützlich, in denen die CLI oder YAML bevorzugt wird.

Sie müssen diese Ressourcen für dieses Tutorial nicht explizit installieren, da sie in den hier gezeigten Setupanweisungen durch die Datei conda.yaml abgedeckt werden.

So bereiten Sie die Notebook-Umgebung für die Entwicklung vor

Klonen Sie mit dem folgenden Befehl das Repository azureml-examples in Ihren lokalen GitHub-Ressourcen:

git clone --depth 1 https://github.com/Azure/azureml-examples

Sie können auch eine ZIP-Datei aus dem Repository azureml-examples herunterladen. Wählen Sie auf dieser Seite zuerst das Dropdownmenü code und dann Download ZIP aus. Entpacken Sie dann den Inhalt in einem Ordner auf Ihrem lokalen Gerät.
Laden Sie das Verzeichnis mit den Feature Store-Beispielen in den Projektarbeitsbereich hoch.
1. Öffnen Sie im Azure Machine Learning-Arbeitsbereich die Benutzeroberfläche von Azure Machine Learning Studio.
2. Wählen Sie im linken Navigationsbereich Notebooks aus.
3. Wählen Sie Ihren Benutzernamen in der Verzeichnisauflistung aus.
4. Wählen Sie die Auslassungspunkte (...) und dann Ordner hochladen aus.
5. Wählen Sie im geklonten Verzeichnispfad den Ordner mit den Feature Store-Beispielen aus: azureml-examples/sdk/python/featurestore-sample.
Führen Sie das Tutorial aus.
- Option 1: Erstellen Sie ein neues Notebook, und führen Sie die Anweisungen in diesem Dokument Schritt für Schritt aus.
- Option 2: Öffnen Sie das vorhandene Notebook featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb. Sie können dieses Dokument geöffnet lassen und darin nachsehen, um Links zur Dokumentation und weitere Erläuterungen zu erhalten.
  1. Wählen Sie oben im Navigationsbereich im Dropdownmenü Compute die Option Serverloses Spark Compute aus. Dieser Vorgang kann ein bis zwei Minuten dauern. Warten Sie, bis auf einer Statusleiste oben Sitzung konfigurieren angezeigt wird.
  2. Wählen Sie in der oberen Statusleiste Sitzung konfigurieren aus.
  3. Wählen Sie Python-Pakete aus.
  4. Wählen Sie Conda-Datei hochladen aus.
  5. Wählen Sie auf Ihrem lokalen Gerät die Datei azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml aus.
  6. (Optional) Erhöhen Sie das Sitzungstimeout (Leerlaufzeit in Minuten), um die Startzeit des serverlosen Spark-Clusters zu verringern.

Diese Codezelle startet die Spark-Sitzung. Es dauert etwa 10 Minuten, um alle Abhängigkeiten zu installieren und die Spark-Sitzung zu starten.

# Run this cell to start the spark session (any code block will start the session ). This can take around 10 mins.
print("start spark session")

Richten Sie das Stammverzeichnis für die Beispiele ein.

import os

# Please update your alias below (or any custom directory you have uploaded the samples to).
# You can find the name from the directory structure in the left navigation.
root_dir = "./Users/<your_user_alias>/featurestore_sample"

if os.path.isdir(root_dir):
    print("The folder exists.")
else:
    print("The folder does not exist. Please create or fix the path")

Richten Sie die Azure Machine Learning-CLI ein:
- Installieren der Azure Machine Learning-CLI-Erweiterung
```
# install azure ml cli extension
!az extension add --name ml
```
- Authenticate
```
# authenticate
!az login
```
- Festlegen des Standardabonnements
```
# Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```
Hinweis

Ein Feature Store-Arbeitsbereich unterstützt die projektübergreifende Wiederverwendung von Features. Ein Projektarbeitsbereich – der aktuell verwendete Arbeitsbereich – nutzt Features aus einem bestimmten Feature Store, um Modelle zu trainieren und Rückschlüsse dafür zu ziehen. Viele Projektarbeitsbereiche können denselben Feature Store-Arbeitsbereich gemeinsam nutzen und wiederverwenden.

Bereitstellen der erforderlichen Ressourcen

Sie können ein neues Speicherkonto und Container für ADLS Gen2 (Azure Data Lake Storage) erstellen oder vorhandene Speicherkonten und Containerressourcen für den Feature Store wiederverwenden. In einer realen Situation können unterschiedliche Speicherkonten die ADLS Gen2-Container hosten. Beide Optionen funktionieren je nach Ihren spezifischen Anforderungen.

In diesem Tutorial erstellen Sie drei separate Speichercontainer im selben ADLS Gen2-Speicherkonto:

Quelldaten
Offlinespeicher
Beobachtungsdaten

Erstellen Sie ein ADLS Gen2-Speicherkonto für Quelldaten, Offlinespeicher und Beobachtungsdaten.

Geben Sie im folgenden Codebeispiel den Namen eines Azure Data Lake Storage Gen2-Speicherkontos an. Sie können die folgende Codezelle mit den angegebenen Standardeinstellungen ausführen. Sie können optional die Standardeinstellungen überschreiben.

## Default Setting
# We use the subscription, resource group, region of this active project workspace,
# We hard-coded default resource names for creating new resources

## Overwrite
# You can replace them if you want to create the resources in a different subsciprtion/resourceGroup, or use existing resources
# At the minimum, provide an ADLS Gen2 storage account name for `storage_account_name`

storage_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
storage_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
storage_account_name = "<STORAGE_ACCOUNT_NAME>"

storage_location = "eastus"
storage_file_system_name_offline_store = "offline-store"
storage_file_system_name_source_data = "source-data"
storage_file_system_name_observation_data = "observation-data"

Diese Codezelle erstellt das ADLS Gen2-Speicherkonto, das in der obigen Codezelle definiert ist:

# Create new storage account
!az storage account create --name $storage_account_name --enable-hierarchical-namespace true --resource-group $storage_resource_group_name --location $storage_location --subscription $storage_subscription_id

Diese Codezelle erstellt einen neuen Speichercontainer für den Offlinespeicher:

# Create a new storage container for offline store
!az storage fs create --name $storage_file_system_name_offline_store --account-name $storage_account_name --subscription $storage_subscription_id

Diese Codezelle erstellt einen neuen Speichercontainer für Quelldaten:

# Create a new storage container for source data
!az storage fs create --name $storage_file_system_name_source_data --account-name $storage_account_name --subscription $storage_subscription_id

Diese Codezelle erstellt einen neuen Speichercontainer für Beobachtungsdaten:

# Create a new storage container for observation data
!az storage fs create --name $storage_file_system_name_observation_data --account-name $storage_account_name --subscription $storage_subscription_id

Kopieren Sie die für diese Tutorialreihe erforderlichen Beispieldaten in die neu erstellten Speichercontainer.

Um Daten in die Speichercontainer zu schreiben, stellen Sie sicher, dass die Rollen Mitwirkender und Mitwirkender an Storage-Blobdaten der Benutzeridentität des erstellten ADLS Gen2-Speicherkontos im Azure-Portal zugewiesen werden. Führen Sie dazu diese Schritte aus.

Wichtig

Wenn Sie sich vergewissert haben, dass die Rollen Mitwirkender und Mitwirkender an Storage-Blobdaten der Benutzeridentität zugewiesen sind, warten Sie einige Minuten nach der Rollenzuweisung, damit Berechtigungen weitergegeben werden, bevor Sie mit den nächsten Schritten fortfahren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Rollenbasierte Zugriffssteuerung (Azure Role-Based Access Control, Azure RBAC).

Die nächsten Codezellen kopieren Beispielquelldaten für den in diesem Tutorial verwendeten Transaktionsfeaturesatz aus einem öffentlichen Speicherkonto in das neu erstellte Speicherkonto:
```
# Copy sample source data for transactions feature set used in this tutorial series from the public storage account to the newly created storage account
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)

transactions_src_df.write.parquet(
    f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/transactions-source/"
)
```

Kopieren Sie für den in diesem Lernprogramm verwendeten Kontofeaturesatz die Beispielquelldaten für das Kontofeature in das neu erstellte Speicherkonto.

# Copy sample source data for account feature set used in this tutorial series from the public storage account to the newly created storage account
accounts_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet"
accounts_data_df = spark.read.parquet(accounts_data_path)

accounts_data_df.write.parquet(
    f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/accounts-precalculated/"
)

Kopieren Sie die für das Training verwendeten Beispielbeobachtungsdaten aus einem öffentlichen Speicherkonto in das neu erstellte Speicherkonto:

# Copy sample observation data used for training from the public storage account to the newly created storage account
observation_data_train_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"
observation_data_train_df = spark.read.parquet(observation_data_train_path)

observation_data_train_df.write.parquet(
    f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/train/"
)

Kopieren Sie die für Batchrückschlüsse verwendeten Beispielbeobachtungsdaten aus einem öffentlichen Speicherkonto in das neu erstellte Speicherkonto:

# Copy sample observation data used for batch inference from a public storage account to the newly created storage account
observation_data_inference_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/batch_inference/*.parquet"
observation_data_inference_df = spark.read.parquet(observation_data_inference_path)

observation_data_inference_df.write.parquet(
    f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/batch_inference/"
)

Deaktivieren Sie den Zugriff über öffentliche Netzwerke für das neu erstellte Speicherkonto.

Diese Codezelle deaktiviert den Zugriff über öffentliche Netzwerke für das zuvor erstellte ADLS Gen2-Speicherkonto:

# Disable the public network access for the above created ADLS Gen2 storage account
!az storage account update --name $storage_account_name --resource-group $storage_resource_group_name --subscription $storage_subscription_id --public-network-access disabled

Legen Sie ARM-IDs für den Offlinespeicher sowie die Quelldaten- und Beobachtungsdatencontainer fest:

# set the container arm id
offline_store_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,
)

print(offline_store_gen2_container_arm_id)

source_data_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_source_data,
)

print(source_data_gen2_container_arm_id)

observation_data_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_observation_data,
)

print(observation_data_gen2_container_arm_id)

Erstellen eines Feature Store mit aktivierter Materialisierung

Festlegen der Feature Store-Parameter

Legen Sie den Namen des Feature Store, den Standort, die Abonnement-ID, den Gruppennamen und die ARM-ID fest, wie in diesem Codezellenbeispiel gezeigt:

# We use the subscription, resource group, region of this active project workspace.
# Optionally, you can replace them to create the resources in a different subsciprtion/resourceGroup, or use existing resources
import os

# At the minimum, define a name for the feature store
featurestore_name = "<FEATURESTORE_NAME>"
# It is recommended to create featurestore in the same location as the storage
featurestore_location = storage_location
featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

feature_store_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.MachineLearningServices/workspaces/{ws_name}".format(
    sub_id=featurestore_subscription_id,
    rg=featurestore_resource_group_name,
    ws_name=featurestore_name,
)

Diese Codezelle generiert eine YAML-Spezifikationsdatei für einen Featurespeicher mit aktivierter Materialisierung.

# The below code creates a feature store with enabled materialization
import yaml

config = {
    "$schema": "http://azureml/sdk-2-0/FeatureStore.json",
    "name": featurestore_name,
    "location": featurestore_location,
    "compute_runtime": {"spark_runtime_version": "3.3"},
    "offline_store": {
        "type": "azure_data_lake_gen2",
        "target": offline_store_gen2_container_arm_id,
    },
}

feature_store_yaml = root_dir + "/featurestore/featurestore_with_offline_setting.yaml"

with open(feature_store_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Erstellen des Feature Stores

Diese Codezelle verwendet die YAML-Spezifikationsdatei, die im vorherigen Schritt generiert wurde, um einen Featurespeicher mit aktivierter Materialisierung zu erstellen.

!az ml feature-store create --file $feature_store_yaml --subscription $featurestore_subscription_id --resource-group $featurestore_resource_group_name

Initialisieren des Azure Machine Learning Feature Store Core SDK-Clients

Der in dieser Zelle initialisierte SDK-Client erleichtert die Entwicklung und Nutzung von Features:

# 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,
)

Weisen Sie der Benutzeridentität im Featurespeicher Rollen zu.

Befolgen Sie die Anweisungen zum Abrufen der Microsoft Entra-Objekt-ID für Ihre Benutzeridentität. Verwenden Sie dann Ihre Microsoft Entra ID-Objekt-ID im nächsten Befehl, um Ihrer Benutzeridentität für den erstellten Featurespeicher die Rolle AzureML – Wissenschaftliche Fachkraft für Daten zuzuweisen.

your_aad_objectid = "<YOUR_AAD_OBJECT_ID>"

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

Abrufen des Standardspeicherkontos und des Schlüsseltresors für den Feature Store und Deaktivieren des Zugriffs auf die entsprechenden Ressourcen über öffentliche Netzwerke

Die nächste Codezelle gibt das Featurespeicherobjekt für die nächsten Schritte zurück.

fs = featurestore.feature_stores.get()

Diese Codezelle gibt die Namen des Standardspeicherkontos und des Schlüsseltresors für den Featurespeicher zurück.

# Copy the properties storage_account and key_vault from the response returned in feature store show command respectively
default_fs_storage_account_name = fs.storage_account.rsplit("/", 1)[-1]
default_key_vault_name = fs.key_vault.rsplit("/", 1)[-1]

Die folgende Codezelle deaktiviert den Zugriff auf das Standardspeicherkonto über öffentliche Netzwerke für den Feature Store:

# Disable the public network access for the above created default ADLS Gen2 storage account for the feature store
!az storage account update --name $default_fs_storage_account_name --resource-group $featurestore_resource_group_name --subscription $featurestore_subscription_id --public-network-access disabled

Die nächste Zelle gibt den Namen des Standardschlüsseltresors für den Featurespeicher aus.

print(default_key_vault_name)

Deaktivieren des Zugriffs über öffentliche Netzwerke für den zuvor erstellten Standardschlüsseltresor des Feature Store

Öffnen Sie im Azure-Portal den Standardschlüsseltresor, den Sie in der vorherigen Zelle erstellt haben.
Wählen Sie die Registerkarte Netzwerk aus.
Wählen Sie Öffentlichen Zugriff deaktivieren und dann unten links auf der Seite Anwenden aus.

Aktivieren des verwalteten virtuellen Netzwerks für den Feature Store-Arbeitsbereich

Aktualisieren des Feature Store mit den erforderlichen Ausgangsregeln

Die nächste Codezelle erstellt eine YAML-Spezifikationsdatei für Ausgangsregeln, die für den Featurespeicher definiert sind.

# The below code creates a configuration for managed virtual network for the feature store
import yaml

config = {
    "public_network_access": "disabled",
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            # You need to add multiple rules here if you have separate storage account for source, observation data and offline store.
            {
                "name": "sourcerulefs",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "dfs",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Storage/storageAccounts/{storage_account_name}",
                },
                "type": "private_endpoint",
            },
            # This rule is added currently because serverless Spark doesn't automatically create a private endpoint to default key vault.
            {
                "name": "defaultkeyvault",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "vault",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.Keyvault/vaults/{default_key_vault_name}",
                },
                "type": "private_endpoint",
            },
        ],
    },
}

feature_store_managed_vnet_yaml = (
    root_dir + "/featurestore/feature_store_managed_vnet_config.yaml"
)

with open(feature_store_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Diese Codezelle verwendet die generierte YAML-Spezifikationsdatei, um den Featurespeicher zu aktualisieren.

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

Erstellen privater Endpunkte für die definierten Ausgangsregeln

Ein provision-network-Befehl erstellt private Endpunkte aus dem verwalteten virtuellen Netzwerk, in dem der Materialisierungsauftrag ausgeführt wird, für die Quelle, den Offlinespeicher, die Beobachtungsdaten, das Standardspeicherkonto und den Standardschlüsseltresor für den Featurespeicher. Die Ausführung dieses Befehls kann etwa 20 Minuten dauern.

#### Provision network to create necessary private endpoints (it may take approximately 20 minutes)
!az ml feature-store provision-network --name $featurestore_name --resource-group $featurestore_resource_group_name --include-spark

Diese Codezelle überprüft, ob die durch die Ausgangsregeln definierten privaten Endpunkte erstellt wurden.

### Check that managed virtual network is correctly enabled
### After provisioning the network, all the outbound rules should become active
### For this tutorial, you will see 6 outbound rules
!az ml feature-store show --name $featurestore_name --resource-group $featurestore_resource_group_name

Aktualisieren des verwalteten virtuellen Netzwerks für den Projektarbeitsbereich

Aktualisieren Sie als Nächstes das verwaltete virtuelle Netzwerk für den Projektarbeitsbereich. Rufen Sie zunächst die Abonnement-ID, die Ressourcengruppe und den Arbeitsbereichsnamen für den Projektarbeitsbereich ab.

# lookup the subscription id, resource group and workspace name of the current workspace
project_ws_sub_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
project_ws_rg = os.environ["AZUREML_ARM_RESOURCEGROUP"]
project_ws_name = os.environ["AZUREML_ARM_WORKSPACE_NAME"]

Aktualisieren des Projektarbeitsbereichs mit den erforderlichen Ausgangsregeln

Der Projektarbeitsbereich benötigt Zugriff auf die folgenden Ressourcen:

Quelldaten
Offlinespeicher
Beobachtungsdaten
Featurespeicher
Standardspeicherkonto des Feature Store

Diese Codezelle aktualisiert den Projektarbeitsbereich mithilfe der generierten YAML-Spezifikationsdatei mit den erforderlichen Ausgangsregeln:

# The below code creates a configuration for managed virtual network for the project workspace
import yaml

config = {
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            # Incase you have separate storage accounts for source, observation data and offline store, you need to add multiple rules here. No action needed otherwise.
            {
                "name": "projectsourcerule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "dfs",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Storage/storageAccounts/{storage_account_name}",
                },
                "type": "private_endpoint",
            },
            # Rule to create private endpoint to default storage of feature store
            {
                "name": "defaultfsstoragerule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "blob",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.Storage/storageAccounts/{default_fs_storage_account_name}",
                },
                "type": "private_endpoint",
            },
            # Rule to create private endpoint to default key vault of feature store
            {
                "name": "defaultfskeyvaultrule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "vault",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.Keyvault/vaults/{default_key_vault_name}",
                },
                "type": "private_endpoint",
            },
            # Rule to create private endpoint to feature store
            {
                "name": "featurestorerule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "amlworkspace",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.MachineLearningServices/workspaces/{featurestore_name}",
                },
                "type": "private_endpoint",
            },
        ],
    }
}

project_ws_managed_vnet_yaml = (
    root_dir + "/featurestore/project_ws_managed_vnet_config.yaml"
)

with open(project_ws_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Diese Codezelle aktualisiert den Projektarbeitsbereich mithilfe der generierten YAML-Spezifikationsdatei mit den Ausgangsregeln:

#### Update project workspace to create private endpoints for the defined outbound rules (it may take approximately 15 minutes)
!az ml workspace update --file $project_ws_managed_vnet_yaml --name $project_ws_name --resource-group $project_ws_rg

Diese Codezelle überprüft, ob die durch die Ausgangsregeln definierten privaten Endpunkte erstellt wurden.

!az ml workspace show --name $project_ws_name --resource-group $project_ws_rg

Sie können auch die Ausgangsregeln im Azure-Portal überprüfen. Navigieren Sie im linken Navigationsbereich des Projektarbeitsbereichs zu Networking und öffnen Sie dann die Registerkarte Vom Arbeitsbereich verwalteter ausgehender Zugriff.

Erstellen eines Prototyps und Entwickeln eines Featuresatzes für die rollierende Aggregation von Transaktionen

Untersuchen der Transaktionsquelldaten

Hinweis

Ein öffentlich zugänglicher Blobcontainer hostet die in diesem Tutorial verwendeten Beispieldaten. Er kann in Spark nur über den wasbs-Treiber gelesen werden. Wenn Sie Funktionssätze mit Ihren eigenen Quelldaten erstellen, hosten Sie diese in einem ADLS Gen2-Konto, und verwenden Sie einen abfss-Treiber im Datenpfad.

# remove the "." in the root directory path as we need to generate absolute path to read from Spark
transactions_source_data_path = f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/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

Lokales Entwickeln eines Transaktionsfeaturesatzes

Eine Featuresatzspezifikation ist eine eigenständige Featuresatzdefinition, die lokal entwickelt und getestet werden kann.

Erstellen Sie die folgenden Features für rollierende Zeitfensteraggregationen:

Anzahl von Transaktionen für drei Tage
Summe der Transaktionsbeträge für drei Tage
Durchschnittlicher Transaktionsbetrag für drei Tage
Anzahl von Transaktionen für sieben Tage
Summe der Transaktionsbeträge für sieben Tage
Durchschnittlicher Transaktionsbetrag für sieben Tage

Überprüfen Sie die Codedatei für die Featuretransformation: featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.py. Dieser Spark-Transformator führt die für die Features definierte rollierende Aggregation aus.

Weitere Informationen zu den Featuresätzen und Transformationen finden Sie unter Featurespeicher – Konzepte.

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


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

transactions_featureset_spec = create_feature_set_spec(
    source=FeatureSource(
        type=SourceType.parquet,
        path=f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/transactions-source/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
        source_delay=DateTimeOffset(days=0, hours=0, minutes=20),
    ),
    transformation_code=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,
)
# Generate a spark dataframe from the feature set specification
transactions_fset_df = transactions_featureset_spec.to_spark_dataframe()
# display few records
display(transactions_fset_df.head(5))

Exportieren einer Featuresatzspezifikation

Um eine Featuresatzspezifikation beim Feature Store zu registrieren, muss diese Featuresatzspezifikation in einem bestimmten Format gespeichert werden.

Um die Spezifikation des generierten Transaktionsfeaturesatzes zu überprüfen, öffnen Sie die folgende Datei in der Dateistruktur, um die Spezifikation anzuzeigen:

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

Die Spezifikation enthält die folgenden Elemente:

source: Ein Verweis auf eine Speicherressource, in diesem Fall eine Parquet-Datei in einer Blobspeicherressource
features: Eine Liste der Features und ihrer Datentypen. Bei Bereitstellung von Transformationscode
index_columns: Die Joinschlüssel, die für den Zugriff auf Werte aus der Funktionsgruppe erforderlich sind

Ein weiterer Vorteil der Beibehaltung einer Featuresatzspezifikation als YAML-Datei ist die Versionskontrolle für die Spezifikation. Weitere Informationen zur Featuresatzspezifikation finden Sie im Dokument mit den Feature Store-Entitäten der obersten Ebene und in der YAML-Referenz zur Featuresatzspezifikation.

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 not
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)

Registrieren einer Feature Store-Entität

Entitäten helfen dabei, die Verwendung derselben Joinschlüsseldefinitionen für Featuresätze zu erzwingen, die dieselben logischen Entitäten verwenden. Beispiele für Entitäten können Kontoentitäten, Kundenentitäten usw. sein. Entitäten werden in der Regel einmal erstellt und dann über Featuresätze hinweg wiederverwendet. Weitere Informationen finden Sie im Dokument mit den Featurespeicher-Entitäten der obersten Ebene.

Diese Codezelle erstellt eine Kontoentität für den Feature Store:

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 --workspace-name $featurestore_name

Registrieren des Transaktionsfeaturesatzes beim Feature Store und Übermitteln eines Materialisierungsauftrags

Zum Freigeben und Wiederverwenden einer Featuresatzressource müssen Sie diese Ressource zuerst beim Feature Store registrieren. Die Ressourcenregistrierung für den Featuresatz bietet verwaltete Funktionen, einschließlich Versionsverwaltung und Materialisierung. In dieser Tutorialreihe werden diese Themen behandelt.

Die Featuresatzressource verweist sowohl auf die Featuresatzspezifikation, die Sie zuvor erstellt haben, als auch auf andere Eigenschaften, z. B. Versions- und Materialisierungseinstellungen.

Erstellen einer Featuregruppe

Die nächste Codezelle verwendet eine vordefinierte YAML-Spezifikationsdatei, um einen Featuresatz zu erstellen.

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

Diese Codezelle zeigt eine Vorschau des neu erstellten Featuresatzes an:

# Preview the newly created feature set

!az ml feature-set show --resource-group $featurestore_resource_group_name --workspace-name $featurestore_name -n transactions -v 1

Übermitteln eines Abgleichmaterialisierungsauftrags

Die nächste Codezelle definiert Start- und Endzeitwerte für das Featurematerialisierungsfenster und übermittelt einen Abgleichmaterialisierungsauftrag.

feature_window_start_time = "2023-02-01T00:00.000Z"
feature_window_end_time = "2023-03-01T00:00.000Z"

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

Diese Codezelle stellt <JOB_ID_FROM_PREVIOUS_COMMAND> bereit, um den Status des Abgleichmaterialisierungsauftrags zu überprüfen.

### Check the job status

!az ml job show --name <JOB_ID_FROM_PREVIOUS_COMMAND> -g $featurestore_resource_group_name -w $featurestore_name

Diese Codezelle listet alle Materialisierungsaufträge für den aktuellen Featuresatz auf.

### List all the materialization jobs for the current feature set

!az ml feature-set list-materialization-operation --name transactions --version 1 -g $featurestore_resource_group_name -w $featurestore_name

Anfügen des Azure Cache for Redis als Onlinespeicher

Erstellen einer Azure Cache for Redis-Instanz

Definieren Sie in der nächsten Codezelle den Namen der Azure Cache for Redis-Ressource, die Sie erstellen oder wiederverwenden möchten. Sie können optional andere Standardeinstellungen überschreiben.

redis_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
redis_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
redis_name = "my-redis"
redis_location = storage_location

Sie können die Redis Cache-Ebene (Basic, Standard oder Premium) auswählen. Sie sollten eine SKU-Familie auswählen, die für die ausgewählte Cacheebene verfügbar ist. Sehen Sie sich diese Dokumentationsressource an, um weitere Informationen darüber zu erhalten, wie sich die Auswahl verschiedener Ebenen auf die Cacheleistung auswirken kann. Sehen Sie sich diese Dokumentationsressource an, um weitere Informationen zum Preis für verschiedene SKU-Ebenen und Familien von Azure Cache for Redis zu erhalten.

Führen Sie die folgende Codezelle aus, um eine Azure Cache for Redis-Instanz mit Premium-Tarif, SKU-Familie P und Cachekapazität 2 zu erstellen. Es kann ungefähr 5 bis 10 Minuten dauern, bis die Redis-Instanz bereitgestellt wird.

# Create new redis cache
from azure.mgmt.redis import RedisManagementClient
from azure.mgmt.redis.models import RedisCreateParameters, Sku, SkuFamily, SkuName

management_client = RedisManagementClient(
    AzureMLOnBehalfOfCredential(), redis_subscription_id
)

# It usually takes about 5 - 10 min to finish the provision of the Redis instance.
# If the following begin_create() call still hangs for longer than that,
# please check the status of the Redis instance on the Azure portal and cancel the cell if the provision has completed.
# This sample uses a PREMIUM tier Redis SKU from family P, which may cost more than a STANDARD tier SKU from family C.
# Please choose the SKU tier and family according to your performance and pricing requirements.

redis_arm_id = (
    management_client.redis.begin_create(
        resource_group_name=redis_resource_group_name,
        name=redis_name,
        parameters=RedisCreateParameters(
            location=redis_location,
            sku=Sku(name=SkuName.PREMIUM, family=SkuFamily.P, capacity=2),
            public_network_access="Disabled",  # can only disable PNA to redis cache during creation
        ),
    )
    .result()
    .id
)
print(redis_arm_id)

Aktualisieren des Featurespeichers mit dem Onlinespeicher

Fügen Sie den Azure Cache for Redis an den Featurespeicher an, um ihn als Online-Materialisierungsspeicher zu verwenden. Die nächste Codezelle erstellt eine YAML-Spezifikationsdatei mit Ausgangsregeln für Onlinespeicher, die für den Featurespeicher definiert sind.

# The following code cell creates a YAML specification file for outbound rules that are defined for the feature store.
## rule 1: PE to online store (redis cache): this is optional if online store is not used

import yaml

config = {
    "public_network_access": "disabled",
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            {
                "name": "sourceruleredis",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "redisCache",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Cache/Redis/{redis_name}",
                },
                "type": "private_endpoint",
            },
        ],
    },
    "online_store": {"target": f"{redis_arm_id}", "type": "redis"},
}

feature_store_managed_vnet_yaml = (
    root_dir + "/featurestore/feature_store_managed_vnet_config.yaml"
)

with open(feature_store_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Die nächste Codezelle aktualisiert den Featurespeicher mithilfe der generierten YAML-Spezifikationsdatei mit den Ausgangsregeln für den Onlinespeicher.

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

Aktualisieren von Ausgangsregeln für den Projektarbeitsbereich

Der Projektarbeitsbereich benötigt Zugriff auf den Onlinespeicher. Die folgende Codezelle erstellt eine YAML-Spezifikationsdatei mit den erforderlichen Ausgangsregeln für den Projektarbeitsbereich.

import yaml

config = {
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            {
                "name": "onlineruleredis",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "redisCache",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Cache/Redis/{redis_name}",
                },
                "type": "private_endpoint",
            },
        ],
    }
}

project_ws_managed_vnet_yaml = (
    root_dir + "/featurestore/project_ws_managed_vnet_config.yaml"
)

with open(project_ws_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Führen Sie die nächste Codezelle aus, um den Projektarbeitsbereich mithilfe der generierten YAML-Spezifikationsdatei mit den Ausgangsregeln für den Onlinespeicher zu aktualisieren.

#### Update project workspace to create private endpoints for the defined outbound rules (it may take approximately 15 minutes)
!az ml workspace update --file $project_ws_managed_vnet_yaml --name $project_ws_name --resource-group $project_ws_rg

Materialisieren des Transaktions-Featuresatzes im Onlinespeicher

Die nächste Codezelle ermöglicht die Onlinematerialisierung des transactions-Featuresatzes.

# Update featureset to enable online materialization
transactions_featureset_path = (
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_online_enabled.yaml"
)
!az ml feature-set update --file $transactions_featureset_path --resource-group $featurestore_resource_group_name --workspace-name $featurestore_name

Die nächste Codezelle definiert die Start- und Endzeit für das Featurematerialisierungsfenster und übermittelt einen Abgleichmaterialisierungsauftrag.

feature_window_start_time = "2024-01-24T00:00.000Z"
feature_window_end_time = "2024-01-25T00:00.000Z"

!az ml feature-set backfill --name transactions --version 1 --by-data-status "['None']" --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

Verwenden der registrierten Features zum Generieren von Trainingsdaten

Laden von Beobachtungsdaten

Untersuchen Sie zunächst die Beobachtungsdaten. Die Kerndaten, die beim Training und bei Rückschlüssen verwendet werden, beinhalten in der Regel Beobachtungsdaten. Diese Daten werden dann mit Featuredaten verknüpft, um eine vollständige Trainingsdatenressource zu erstellen. Beobachtungsdaten sind die Daten, die während des Ereignisses erfasst werden. In diesem Fall enthalten sie wichtige Transaktionsdaten, einschließlich Transaktions-ID, Konto-ID und Transaktionsbeträgen. Da die Beobachtungsdaten für das Training verwendet werden, wird auch die Zielvariable angefügt (is_fraud).

observation_data_path = f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/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

Abrufen des registrierten Featuresatzes und Auflisten seiner Features

Rufen Sie als Nächstes einen Featuresatz ab, indem Sie seinen Namen und seine Version angeben, und listen Sie dann Features in diesem Featuresatz auf. Geben Sie außerdem einige Beispielfeaturewerte aus.

# look up the featureset by providing name and 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))

Auswählen von Features und Generieren von Trainingsdaten

Wählen Sie Features für die Trainingsdaten aus, und verwenden Sie das Feature Store SDK, um die Trainingsdaten zu generieren.

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: featurestore:featureset:version:feature
more_features = [
    "transactions:1:transaction_3d_count",
    "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 next 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

Ein Zeitpunktjoin hat die Features an die Trainingsdaten angefügt.

Optionale nächste Schritte

Nachdem Sie nun erfolgreich einen sicheren Feature Store erstellt und eine erfolgreiche Materialisierungsausführung übermittelt haben, können Sie die Tutorialreihe durchlaufen, um sich mit dem Featurespeicher vertraut zu machen.

Dieses Tutorial enthält eine Mischung aus den Schritten aus Tutorial 1 und 2 dieser Reihe. Denken Sie daran, die erforderlichen öffentlichen Speichercontainer, die in den anderen Tutorial-Notebooks verwendet werden, durch die in diesem Tutorial-Notebook erstellten Container für die Netzwerkisolation zu ersetzen.

Wir sind am Ende des Tutorials angelangt. Ihre Trainingsdaten verwenden Features aus einem Feature Store. Sie können sie zur späteren Verwendung im Speicher speichern oder direkt das Modelltraining dafür ausführen.

Freigeben über