Zelfstudie 6: Netwerkisolatie met functiearchief

Met een door Azure Machine Learning beheerd functiearchief 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 gaat verder met de operationele fase, waar u uw modellen implementeert en deductiestappen zoeken naar de functiegegevens. Lees het document met concepten van het functiearchief voor meer informatie over functiearchieven.

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

Deel 1 van deze reeks zelfstudies liet zien hoe u een specificatie van een functieset maakt met aangepaste transformaties en deze functieset gebruikt om trainingsgegevens te genereren. Deel 2 van de serie liet zien hoe u materialisatie mogelijk maakt en een backfill uitvoert. Daarnaast liet deel 2 zien hoe u kunt experimenteren met functies, als een manier om de modelprestaties te verbeteren. Deel 3 liet zien hoe een functiearchief de flexibiliteit vergroot in de experimenten en trainingsstromen. In deel 3 wordt ook beschreven hoe batchdeductie moet worden uitgevoerd. In zelfstudie 4 wordt uitgelegd hoe u functiearchief gebruikt voor gebruiksvoorbeelden voor online/realtime deductie. Zelfstudie 5 demonstreerde hoe u een functieset ontwikkelt met een aangepaste gegevensbron. Zelfstudie 6 laat zien hoe u

• Stel de benodigde resources in voor netwerkisolatie van een beheerd functiearchief.
• Maak een nieuwe resource voor het functiearchief.
• Stel uw functiearchief in om netwerkisolatiescenario's te ondersteunen.
• Werk uw projectwerkruimte (huidige werkruimte) bij om netwerkisolatiescenario's te ondersteunen.

Vereisten

Notitie

In deze zelfstudie wordt gebruikgemaakt van een Azure Machine Learning-notebook met Serverless Spark Compute.

• Een Azure Machine Learning-werkruimte, ingeschakeld met 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 functiearchief maakt. Uw gebruikersaccount heeft ook de User Access Administrator rol nodig.

Belangrijk

Voor uw Azure Machine Learning-werkruimte stelt u het in isolation_mode op allow_internet_outbound. Dit is de enige ondersteunde netwerkisolatiemodus. Deze zelfstudie laat zien hoe u veilig verbinding maakt met bronnen, materialisatieopslag en observatiegegevens via privé-eindpunten.

Instellingen

In deze zelfstudie wordt gebruikgemaakt van de Python Feature Store Core SDK (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), in functiearchieven, onderdelensets en entiteiten voor het onderdelenarchief. 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 selecteer Download ZIPvervolgens . Pak vervolgens de inhoud uit in een map op uw lokale apparaat.

2. De map met voorbeelden van de functieopslag uploaden naar de projectwerkruimte

   1. Open in de Azure Machine Learning-werkruimte de gebruikersinterface van Azure Machine Learning-studio
   2. Notitieblokken selecteren in het linkernavigatievenster
   3. Selecteer uw gebruikersnaam in de directoryvermelding
   4. Selecteer weglatingstekens (...) en selecteer vervolgens De map Uploaden
   5. Selecteer de map met voorbeelden van het functiearchief in het gekloonde mappad: azureml-examples/sdk/python/featurestore-sample

3. De zelfstudie uitvoeren

   • 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 een statusbalk bovenaan de sessie configureren wordt weergegeven
     2. Selecteer Sessie configureren in de bovenste statusbalk
     3. Python-pakketten selecteren
     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 werkruimte in het functiearchief ondersteunt hergebruik van functies in 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 resources inrichten

U kunt een nieuw Azure Data Lake Storage-opslagaccount (ADLS) Gen2-opslagaccount en -containers maken, of bestaande opslagaccounts en containerbronnen hergebruiken 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, moet u ervoor zorgen dat de rollen Inzender en Inzender voor opslagblobgegevens worden toegewezen aan de gebruikersidentiteit in het gemaakte ADLS Gen2-opslagaccount in Azure Portal door deze stappen uit te voeren.

      Belangrijk

      Zodra u ervoor hebt gezorgd dat de rollen Inzender en Opslagblobgegevensbijdrager zijn toegewezen aan de gebruikersidentiteit, wacht u enkele minuten na de roltoewijzing om machtigingen door te geven voordat u verdergaat met de volgende stappen. Ga naar op rollen gebaseerd toegangsbeheer (RBAC) voor Azure-opslagaccounts voor meer informatie over toegangsbeheer

      De volgende codecellen kopiëren voorbeeldbrongegevens voor transacties die in deze zelfstudie worden gebruikt vanuit een openbaar opslagaccount naar het zojuist gemaakte 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 voorbeeldobservatiegegevens die worden gebruikt voor batchdeductie van een openbaar opslagaccount naar het zojuist gemaakte 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 functiearchief maken waarvoor materialisatie is ingeschakeld

Parameters voor het functiearchief instellen

Stel de naam, locatie, abonnements-id, groepsnaam en ARM-id in, zoals wordt weergegeven in dit codecelvoorbeeld:

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

Het functiearchief maken

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

De Core SDK-client van de Azure Machine Learning-functieopslag initialiseren

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 het functiearchief

Volg deze instructies om de Microsoft Entra-object-id voor uw gebruikersidentiteit op te halen. Gebruik vervolgens uw Microsoft Entra-object-id in de volgende opdracht om de AzureML-Datawetenschapper rol toe te wijzen aan uw gebruikersidentiteit in het gemaakte functiearchief.

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 object voor het functiearchief voor de volgende stappen.

fs = featurestore.feature_stores.get()

Deze codecel retourneert de namen van het standaardopslagaccount en de sleutelkluis voor het functiearchief.

# 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 standaardsleutelkluis voor het functiearchief afgedrukt.

print(default_key_vault_name)

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

• Open in 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 het functiearchief

Het functiearchief bijwerken met de benodigde uitgaande regels

In de volgende codecel wordt een YAML-specificatiebestand gemaakt voor de uitgaande regels die zijn gedefinieerd voor het functiearchief.

# 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, waarbij de materialisatietaak wordt uitgevoerd naar de bron, offlineopslag, observatiegegevens, standaardopslagaccount en de standaardsleutelkluis voor het functiearchief. 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
• Functiearchief
• Standaardopslagaccount van functiearchief

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 Azure Portal. Navigeer vanuit het linkernavigatievenster naar Netwerken voor de projectwerkruimte en open vervolgens het tabblad Beheerde uitgaande toegang voor werkruimte.

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

De gegevens van de transactiebron verkennen

Notitie

Een openbaar toegankelijke blobcontainer fungeert als host voor de voorbeeldgegevens die in deze zelfstudie worden gebruikt. Het kan alleen worden gelezen in Spark via wasbs het stuurprogramma. Wanneer u functiesets maakt met behulp van uw eigen brongegevens, moet u deze hosten in een ADLS Gen2-account en een abfss stuurprogramma in het gegevenspad gebruiken.

# 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 statistische functies voor rolling window:

• aantal transacties van drie dagen
• transactiebedrag van drie dagen
• bedrag van drie dagen
• transacties zeven dagen tellen
• transactiebedrag zeven dagen
• bedrag van zeven dagen

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

Voor meer informatie over de functieset en transformaties gaat u naar concepten van het functiearchief.

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 specificatie van een functieset wilt registreren bij het functiearchief, moet die specificatie worden opgeslagen in een specifieke indeling.

Als u de specificatie van de gegenereerde transactiesset wilt controleren, opent u dit bestand vanuit de bestandsstructuur 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 het functiearchief 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 deze codecel maakt u een accountentiteit voor het functiearchief.

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 transactiefunctieset bij het functiearchief en verzend een materialisatietaak

Als u een onderdelensetasset wilt delen en opnieuw wilt gebruiken, moet u die asset eerst registreren bij het functiearchief. De registratie van functiesetassets biedt beheerde mogelijkheden, waaronder versiebeheer en materialisatie. In deze reeks zelfstudies 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 bekijkt een voorbeeld van de zojuist gemaakte functieset.

# 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 venster functiever materialisatie en verzendt een backfill-materialisatietaak.

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 online winkel bijvoegen

Een Azure Cache voor Redis-instantie 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. Raadpleeg 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 premiumlaag, SKU-serie P en cachecapaciteit 2. Het kan ongeveer 5-10 minuten duren voordat het Redis-exemplaar is ingericht.

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

Functiearchief bijwerken met de online winkel

Koppel de Azure Cache voor Redis aan de functieopslag om deze als online materialisatiearchief te gebruiken. In de volgende codecel wordt een YAML-specificatiebestand gemaakt met uitgaande regels voor online winkels die zijn gedefinieerd voor het functiearchief.

# 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 Transacties materialiseren die is ingesteld op 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 venster voor functiever materialisatie en verzendt een backfill-materialisatietaak.

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 functies toegevoegd aan de trainingsgegevens.

Optionele volgende stappen

Nu u een beveiligd functiearchief hebt gemaakt en een geslaagde materialisatieuitvoering hebt ingediend, kunt u doorgaan met de reeks zelfstudies om inzicht te krijgen in het functiearchief.

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

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

Volgende stappen

• Deel 2: Experimenteer en train modellen met behulp van functies
• Deel 3: Terugkerende materialisatie inschakelen en batchdeductie uitvoeren