Zelfstudie 6: Netwerkisolatie voor de feature store

Met een Azure Machine Learning beheerde functieopslag kunt u functies detecteren, maken en operationeel maken. Functies fungeren als het bindweefsel in de machine learning-levenscyclus, vanaf de prototypefase, waar u experimenteer met verschillende functies. Deze levenscyclus zet zich voort in de operationalisatiefase, waar u uw modellen implementeert en inferentiestappen de kenmerkgegevens opzoeken. Zie Wat is het beheerde functiearchief voor meer informatie over het beheerde functiearchief?

In deze zelfstudie wordt beschreven hoe u beveiligd inkomend verkeer configureert via een privé-eindpunt en uitgaand verkeer beveiligt via een beheerd virtueel netwerk.

Zelfstudie 1 liet zien hoe u een specificatie van een functieset maakt met aangepaste transformaties en vervolgens die functieset gebruikt om trainingsgegevens te genereren, materialisatie in te schakelen en een backfill uit te voeren. Zelfstudie 2 liet zien hoe u kunt experimenteren met functies om de modelprestaties te verbeteren en vervolgens een model te trainen en te registreren dat gebruikmaakt van functies. Zelfstudie 3 liet zien hoe u terugkerende materialisatie voor de transactions functieset inschakelt en een batchdeductiepijplijn uitvoert. Zelfstudie 4 liet zien hoe u online materialisatie inschakelt en online deductie uitvoert. Zelfstudie 5 liet zien hoe u een functieset kunt ontwikkelen met een aangepaste bron. In deze zelfstudie ziet u hoe u

Vereisten

• Een Azure Machine Learning-werkruimte die is ingeschakeld met een beheerd virtueel netwerk voor serverloze spark-taken

• Uw projectwerkruimte configureren:

  1. Maak een YAML-bestand met de naam network.yml:

     managed_network:
     isolation_mode: allow_internet_outbound
     

  2. Voer deze opdrachten uit om de werkruimte bij te werken en het beheerde virtuele netwerk in te richten voor serverloze Spark-taken:

     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
     

  Ga naar Configureren voor serverloze Spark-taak voor meer informatie.

• Aan uw gebruikersaccount moet de Owner of Contributor rol zijn toegewezen aan de resourcegroep waar u het feature store maakt. Uw gebruikersaccount heeft ook de User Access Administrator rol nodig.

Instellen

In deze zelfstudie wordt gebruikgemaakt van de core SDK van de Python feature store (azureml-featurestore). De Python SDK wordt alleen gebruikt voor het ontwikkelen en testen van functiessets. De CLI wordt gebruikt voor CRUD-bewerkingen (create, read, update en delete) op functie-opslag, functiesets en entiteiten voor de functie-opslag. Dit is handig in scenario's voor continue integratie en continue levering (CI/CD) of GitOps waarbij CLI/YAML de voorkeur heeft.

U hoeft deze resources niet expliciet te installeren voor deze zelfstudie, omdat in de hier weergegeven installatie-instructies het conda.yaml bestand deze behandelt.

De notebookomgeving voorbereiden voor ontwikkeling:

1. Kloon de opslagplaats azureml-examples naar uw lokale GitHub resources met deze opdracht:

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

   U kunt ook een zip-bestand downloaden uit de opslagplaats azureml-examples . Selecteer op deze pagina eerst de code vervolgkeuzelijst en vervolgens Download ZIP. Pak vervolgens de inhoud uit in een map op uw lokale apparaat.

2. Upload de directory met feature store voorbeelden naar de projectwerkruimte.

   1. Open in de Azure Machine Learning-werkruimte de gebruikersinterface van Azure Machine Learning Studio
   2. Selecteer Notitieblokken in het linkerdeelvenster
   3. Selecteer uw gebruikersnaam in de directorylijst
   4. Selecteer weglatingstekens (...) en selecteer vervolgens De map Uploaden
   5. Selecteer de voorbeeldmap voor de feature store in het gekloonde mappad: azureml-examples/sdk/python/featurestore-sample

3. De zelfstudie starten

   • Optie 1: Een nieuw notitieblok maken en de instructies in dit document uitvoeren, stap voor stap

   • Optie 2: Bestaand notitieblok openen featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb. U kunt dit document geopend houden en ernaar verwijzen voor meer uitleg en documentatiekoppelingen

     1. Selecteer Serverloze Spark Compute in de bovenste navigatievervolgkeuzelijst Compute . Deze bewerking kan één tot twee minuten duren. Wacht tot er bovenaan een statusbalk verschijnt met de tekst Configureer sessie
     2. Selecteer Sessie configureren in de bovenste statusbalk
     3. Selecteer Python-pakketten
     4. Conda-bestand uploaden selecteren
     5. Selecteer het bestand azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml op uw lokale apparaat
     6. (Optioneel) Verhoog de time-out van de sessie (niet-actieve tijd in minuten) om de opstarttijd van het serverloze Spark-cluster te verminderen

4. Met deze codecel wordt de Spark-sessie gestart. Het duurt ongeveer 10 minuten om alle afhankelijkheden te installeren en de Spark-sessie te 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")

5. De hoofdmap voor de voorbeelden instellen

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

6. De Azure Machine Learning CLI instellen:

   • De Azure Machine Learning CLI-extensie installeren

     # install azure ml cli extension
     !az extension add --name ml

   • Verifiëren

     # authenticate
     !az login

   • Het standaardabonnement instellen

     # Set default subscription
     import os
     
     subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
     
     !az account set -s $subscription_id

   Notitie

   Een feature store-werkruimte ondersteunt het hergebruik van features in verschillende projecten. Een projectwerkruimte , de huidige werkruimte die wordt gebruikt, maakt gebruik van functies uit een specifiek functiearchief, om modellen te trainen en deductie te geven. Veel projectwerkruimten kunnen dezelfde werkruimte voor het functiearchief delen en opnieuw gebruiken.

De benodigde middelen inrichten

U kunt een nieuw Azure Data Lake Storage (ADLS) Gen2-opslagaccount en -containers maken of bestaande opslagaccounts en containerbronnen opnieuw gebruiken voor het functiearchief. In een praktijksituatie kunnen verschillende opslagaccounts de ADLS Gen2-containers hosten. Beide opties werken, afhankelijk van uw specifieke vereisten.

Voor deze zelfstudie maakt u drie afzonderlijke opslagcontainers in hetzelfde ADLS Gen2-opslagaccount:

• Brongegevens
• Offlinestore
• Observatiegegevens

1. Maak een ADLS Gen2-opslagaccount voor brongegevens, offlineopslag en observatiegegevens.

   1. Geef de naam op van een Azure Data Lake Storage Gen2 opslagaccount in het volgende codevoorbeeld. U kunt de volgende codecel uitvoeren met de opgegeven standaardinstellingen. U kunt desgewenst de standaardinstellingen overschrijven.

      ## 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"

   2. In deze codecel wordt het ADLS Gen2-opslagaccount gemaakt dat is gedefinieerd in de bovenstaande codecel.

      # 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

   3. Met deze codecel maakt u een nieuwe opslagcontainer voor offlineopslag.

      # 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

   4. Deze codecel maakt een nieuwe opslagcontainer voor brongegevens.

      # 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

   5. Deze codecel maakt een nieuwe opslagcontainer voor observatiegegevens.

      # 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

2. Kopieer de voorbeeldgegevens die nodig zijn voor deze reeks zelfstudies naar de zojuist gemaakte opslagcontainers.

   1. Als u gegevens naar de opslagcontainers wilt schrijven, zorg ervoor dat Contributor en Storage Blob Data Contributor rollen zijn toegewezen aan de gebruikersidentiteit in het gemaakte ADLS Gen2-opslagaccount in de Azure portal volgend aan deze stappen.

      Belangrijk

      Zodra u ervoor hebt gezorgd dat de rollen Bijdrager en Bijdrager aan opslag-blobgegevens zijn toegewezen aan de gebruikersidentiteit, wacht u enkele minuten na de roltoewijzing om de machtigingen te laten doorgaan voordat u verdergaat met de volgende stappen. Lees meer over toegangscontrole door rolgebaseerde toegangscontrole (RBAC) voor Azure-opslagaccounts te bezoeken.

      De volgende codecellen kopiëren een voorbeeld van brongegevens voor het transacties-functiepakket dat in deze zelfstudie wordt gebruikt, van een openbaar opslagaccount naar het zojuist aangemaakte opslagaccount.

      # 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/"
      )

   2. Voor de accountfunctieset die in deze zelfstudie wordt gebruikt, kopieert u de voorbeeldbrongegevens voor de accountfunctie die is ingesteld op het zojuist gemaakte opslagaccount.

      # 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/"
      )

   3. Kopieer de voorbeeldobservatiegegevens die worden gebruikt voor training van een openbaar opslagaccount naar het zojuist gemaakte opslagaccount.

      # 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/"
      )

   4. Kopieer de voorbeeldgegevens van waarnemingen die gebruikt zijn voor batch-inferentie van een openbaar opslagaccount naar het nieuw aangemaakte opslagaccount.

      # 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/"
      )

3. Schakel de toegang tot het openbare netwerk in het zojuist gemaakte opslagaccount uit.

   1. Met deze codecel wordt openbare netwerktoegang uitgeschakeld voor het ADLS Gen2-opslagaccount dat u eerder hebt gemaakt.

      # 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

   2. STEL ARM-id's in voor de offlineopslag, brongegevens en observatiegegevenscontainers.

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

Een feature store maken waarvoor materialisatie is ingeschakeld

Parameters voor de feature store instellen

Stel de naam van de feature store, locatie, abonnements-id, groepsnaam en ARM-id in, zoals weergegeven in dit voorbeeld van een codecel:

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

Deze codecel genereert een YAML-specificatiebestand voor een functiearchief, waarbij materialisatie is ingeschakeld.

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

Maak de feature store aan

Deze codecel maakt gebruik van het YAML-specificatiebestand dat in de vorige stap is gegenereerd om een functiearchief te maken waarvoor materialisatie is ingeschakeld.

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

Initialiseer de Azure Machine Learning core SDK-client voor de Azure Machine Learning-functieopslag

De SDK-client die in deze cel is geïnitialiseerd, vereenvoudigt het ontwikkelen en verbruik van functies:

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

Rollen toewijzen aan gebruikersidentiteit in de feature store.

Volg deze instructies om de Microsoft Entra Object-id voor uw gebruikersidentiteit te verkrijgen. Gebruik vervolgens uw Microsoft Entra Object-id in de volgende opdracht om de rol AzureML Datawetenschapper toe te wijzen aan uw gebruikersidentiteit in de gemaakte feature store.

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

Haal het standaardopslagaccount en de sleutelkluis voor het functiearchief op en schakel openbare netwerktoegang tot de bijbehorende resources uit

De volgende codecel retourneert het feature store-object voor de volgende stappen.

fs = featurestore.feature_stores.get()

Deze codecel retourneert de namen van het standaard opslagaccount en de key vault voor de feature store.

# 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]

Deze codecel schakelt openbare netwerktoegang tot het standaardopslagaccount voor het functiearchief uit.

# 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

In de volgende cel wordt de naam van de standaard key vault voor de feature store weergegeven.

print(default_key_vault_name)

De openbare netwerktoegang uitschakelen voor de standaardfunctiearchiefsleutelkluis die u eerder hebt gemaakt

• Open in de Azure-portal de standaardsleutelkluis die u in de vorige cel hebt gemaakt.
• Selecteer het tabblad Netwerken.
• Selecteer Openbare toegang uitschakelen en selecteer vervolgens Toepassen linksonder op de pagina.

Het beheerde virtuele netwerk inschakelen voor de werkruimte van de feature store

Het feature store bijwerken met de benodigde uitgaande regels

In de volgende codecel wordt een YAML-specificatiebestand gemaakt voor de gedefinieerde uitgaande regels voor de feature store.

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

In deze codecel wordt het gegenereerde YAML-specificatiebestand gebruikt om het functiearchief bij te werken.

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

Privé-eindpunten maken voor de gedefinieerde uitgaande regels

Met een provision-network opdracht worden privé-eindpunten gemaakt vanuit het beheerde virtuele netwerk, waar de materialisatietaak wordt uitgevoerd naar de bron, offline store, observatiegegevens, standaardopslagaccount en de standaard key vault voor de feature store. Deze opdracht kan ongeveer 20 minuten duren.

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

Deze codecel bevestigt het maken van privé-eindpunten die zijn gedefinieerd door de uitgaande regels.

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

Het beheerde virtuele netwerk voor de projectwerkruimte bijwerken

Werk vervolgens het beheerde virtuele netwerk voor de projectwerkruimte bij. Haal eerst de abonnements-id, resourcegroep en werkruimtenaam op voor de projectwerkruimte.

# 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"]

De projectwerkruimte bijwerken met de benodigde regels voor uitgaand verkeer

De projectwerkruimte heeft toegang nodig tot deze resources:

• Brongegevens
• Offlinestore
• Observatiegegevens
• Featurestore
• Standaardopslagaccount van de feature store

Deze codecel werkt de projectwerkruimte bij met behulp van het gegenereerde YAML-specificatiebestand met de vereiste uitgaande regels.

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

Deze codecel werkt de projectwerkruimte bij met behulp van het gegenereerde YAML-specificatiebestand met de uitgaande regels.

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

Deze codecel bevestigt het maken van privé-eindpunten die zijn gedefinieerd door de uitgaande regels.

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

U kunt ook de uitgaande regels controleren vanuit de Azure-portal. Ga in het linkerdeelvenster naar Netwerken voor de projectruimtes en open vervolgens de tab Beheerde uitgaande toegang voor werkruimte.

Prototype maken en een set functies voor rolling aggregatie van transacties ontwikkelen

De gegevens van de transactiebron verkennen

# 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

Lokaal een transactiefunctieset ontwikkelen

Een specificatie van een functieset is een definitie van een zelfstandige functieset die lokaal kan worden ontwikkeld en getest.

Maak de volgende aggregatiekenmerken voor rollende vensters:

• aantal transacties van drie dagen
• drie-daagse totale som van transacties
• transacties bedrag van drie-dagen gemiddelde
• zeven-daagse transactietelling
• Bedrag van transacties zeven dagen totaal
• transactiebedrag van gemiddelde over zeven dagen

Inspecteer het codebestand featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.pyvoor de functietransformatie. Met deze spark-transformator wordt de lopende aggregatie uitgevoerd die is gedefinieerd voor de kenmerken.

Zie Wat is een managed feature store? voor meer informatie over de functieset en transformaties.

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

Een specificatie van een functieset exporteren

Als u een functiespecificatie wilt registreren bij de feature store, moet die specificatie worden opgeslagen in een specifiek formaat.

Om de specificatie van de gegenereerde transactiekenmerken te controleren, opent u dit bestand vanuit de bestandsboom om de specificatie weer te geven.

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

De specificatie bevat deze elementen:

• source: een verwijzing naar een opslagresource - in dit geval een Parquet-bestand in een blobopslagresource
• features: een lijst met functies en hun gegevenstypen. Als u transformatiecode opgeeft
• index_columns: de joinsleutels die vereist zijn voor toegang tot waarden uit de functieset

Als een ander voordeel van het behouden van een specificatie van een functieset als YAML-bestand, kan de specificatie worden beheerd met versiebeheer. Meer informatie over de specificatie van functieset in het document met entiteiten op het hoogste niveau van het functiearchief en de YAML-verwijzing voor de functiesetspecificatie.

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)

Een entiteit in de feature store registreren

Entiteiten helpen bij het afdwingen van het gebruik van dezelfde joinsleuteldefinities in functiesets die gebruikmaken van dezelfde logische entiteiten. Voorbeelden van entiteiten kunnen accountentiteiten, klantentiteiten, enzovoort zijn. Entiteiten worden doorgaans eenmaal gemaakt en vervolgens opnieuw gebruikt in functiesets. Ga voor meer informatie naar het document met entiteiten op het hoogste niveau van het functiearchief.

Met dit codesegment maakt u een accountentiteit voor de 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

Registreer de transaction feature set bij de feature store en dien een materialisatietaak in.

Als u een kenmerkensetbron wilt delen en hergebruiken, moet u die bron eerst registreren in de functieopslag. Registratie van functieset-assets biedt beheerde mogelijkheden, waaronder versiebeheer en materialisatie. In deze serie tutorials worden deze onderwerpen behandeld.

De functiesetasset verwijst naar zowel de functiesetspecificatie die u eerder hebt gemaakt als andere eigenschappen, bijvoorbeeld versie- en materialisatie-instellingen.

Een functieset maken

In de volgende codecel wordt een vooraf gedefinieerd YAML-specificatiebestand gebruikt om een functieset te maken.

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

Deze codecel toont een voorbeeld van de recentelijk gemaakte featureset.

# 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

Een backfill-materialisatietaak verzenden

De volgende codecel definieert begin- en eindtijdwaarden voor het functiematerialisatievenster en verzendt een opvulmaterialisatietaak.

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

Deze codecel biedt <JOB_ID_FROM_PREVIOUS_COMMAND>, om de status van de backfill-materialisatietaak te controleren.

### Check the job status

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

Deze codecel bevat alle materialisatietaken voor de huidige functieset.

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

Azure Cache voor Redis als een online winkel bijvoegen

Een Azure Cache voor Redis maken

Definieer in de volgende codecel de naam van de Azure Cache voor Redis die u wilt maken of opnieuw wilt gebruiken. U kunt desgewenst andere standaardinstellingen overschrijven.

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

U kunt de Redis-cachelaag (Basic, Standard of Premium) selecteren. U moet een SKU-familie kiezen die beschikbaar is voor de geselecteerde cachelaag. Raadpleeg deze documentatieresource voor meer informatie over hoe de selectie van verschillende lagen van invloed kan zijn op de cacheprestaties. Ga naar deze documentatieresource voor meer informatie over prijzen voor verschillende SKU-lagen en -families van Azure Cache voor Redis.

Voer de volgende codecel uit om een Azure Cache voor Redis te maken met premium-laag, SKU-serie P en cachecapaciteit 2. Het provisioneren van het Redis-exemplaar kan ongeveer 5-10 minuten duren.

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

Functieopslag bijwerken met de online store

Koppel Azure Cache voor Redis aan de kenmerkopslag om deze te gebruiken als online materialisatieopslag. In de volgende codecel wordt een YAML-specificatiebestand gemaakt met uitgaande regels voor online opslag, gedefinieerd voor de feature store.

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

In de volgende codecel wordt het functiearchief bijgewerkt met het gegenereerde YAML-specificatiebestand met de uitgaande regels voor de online winkel.

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

Uitgaande regels voor projectwerkruimten bijwerken

De projectwerkruimte moet toegang hebben tot de online winkel. In de volgende codecel wordt een YAML-specificatiebestand gemaakt met de vereiste uitgaande regels voor de projectwerkruimte.

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)

Voer de volgende codecel uit om de projectwerkruimte bij te werken met het gegenereerde YAML-specificatiebestand met de uitgaande regels voor de online winkel.

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

De functie voor het materialiseren van transacties is ingesteld voor de online winkel.

De volgende codecel maakt online materialisatie mogelijk voor de transactions functieset.

# 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

De volgende codecel definieert de begin- en eindtijden voor het feature-materiaalvenster en verzendt een backfill-materialisatieopdracht.

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

De geregistreerde functies gebruiken om trainingsgegevens te genereren

Observatiegegevens laden

Verken eerst de observatiegegevens. De belangrijkste gegevens die worden gebruikt voor training en deductie, zijn doorgaans observatiegegevens. Deze gegevens worden vervolgens samengevoegd met functiegegevens om een volledige trainingsgegevensresource te maken. Observatiegegevens zijn de gegevens die tijdens de gebeurtenis zijn vastgelegd. In dit geval bevat het kerntransactiegegevens, waaronder transactie-id, account-id en transactiebedragwaarden. Aangezien de observatiegegevens worden gebruikt voor training, wordt ook de doelvariabele (is_fraud) toegevoegd.

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

Haal de geregistreerde functieset op en vermeld de bijbehorende functies

Haal vervolgens een functieset op door de naam en versie op te geven en vervolgens functies in deze functieset weer te geven. Druk ook enkele voorbeeldfunctiewaarden af.

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

Functies selecteren en trainingsgegevens genereren

Selecteer functies voor de trainingsgegevens en gebruik de SDK voor het functiearchief om de trainingsgegevens te genereren.

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

Een punt-in-time join heeft de kenmerken toegevoegd aan de trainingsgegevens.

Optionele volgende stappen

Nu u een beveiligd feature store hebt gemaakt en een geslaagde materialisatierun hebt ingediend, kunt u doorgaan met de reeks tutorials om het feature store beter te begrijpen.

Deze zelfstudie bevat een combinatie van stappen uit zelfstudies 1 en 2 van deze reeks. Vergeet niet om, voor de netwerkisolatie, de benodigde openbare opslagcontainers die in andere handleidingen worden gebruikt, te vervangen door de containers die in dit zelfstudienotitieblok zijn gemaakt.

Hiermee is de zelfstudie beëindigd. Uw trainingsgegevens maken gebruik van kenmerken uit een feature store. U kunt deze opslaan in de opslag voor later gebruik of modeltraining rechtstreeks uitvoeren.

Volgende stappen

• Zelfstudie 2: Modellen experimenteren en trainen met behulp van functies
• Zelfstudie 3: Terugkerende materialisatie inschakelen en batchdeductie uitvoeren