Självstudie 6: Nätverksisolering för feature store

Med ett Azure Machine Learning hanterat funktionsarkiv kan du identifiera, skapa och operationalisera funktioner. Funktioner fungerar som bindväv i maskininlärningslivscykeln, från prototypfasen, där du experimenterar med olika funktioner. Den livscykeln fortsätter till driftsättningsfasen, där du distribuerar dina modeller och härledningsstegen letar upp funktionsdata. Mer information om det hanterade funktionsarkivet finns i Vad är ett hanterat funktionsarkiv?

I den här självstudien beskrivs hur du konfigurerar säker ingress via en privat slutpunkt och säker utgående trafik via ett hanterat virtuellt nätverk.

Självstudie 1 visade hur du skapar en funktionsuppsättningsspecifikation med anpassade transformeringar och sedan använder den funktionsuppsättningen för att generera träningsdata, aktivera materialisering och utföra en återfyllnad. Självstudie 2 visade hur du experimenterar med funktioner för att förbättra modellens prestanda och sedan träna och registrera en modell som använder funktioner. Självstudie 3 visade hur du aktiverar återkommande materialisering för funktionsuppsättningen transactions och kör en pipeline för batchinferens. Självstudie 4 visade hur du aktiverar onlinematerialisering och kör onlineinferens. Självstudie 5 visade hur du utvecklar en funktionsuppsättning med en anpassad källa. Den här självstudien visar hur du

Förutsättningar

• En Azure Machine Learning arbetsyta, aktiverad med hanterat virtuellt nätverk för serverlösa spark-jobb

• Så här konfigurerar du projektarbetsytan:

  1. Skapa en YAML-fil med namnet network.yml:

     managed_network:
     isolation_mode: allow_internet_outbound
     

  2. Kör dessa kommandon för att uppdatera arbetsytan och etablera det hanterade virtuella nätverket för serverlösa Spark-jobb:

     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
     

  Mer information finns i Konfigurera för serverlöst Spark-jobb.

• Ditt användarkonto måste ha rollen Owner eller Contributor tilldelad till resursgruppen där du skapar funktionsarkivet. Ditt användarkonto behöver också User Access Administrator-rollen.

Konfigurera

I den här handledningen används Python feature store core SDK:n (azureml-featurestore). Python SDK används endast för utveckling och testning av funktionsuppsättningar. CLI används för att skapa, läsa, uppdatera och ta bort åtgärder (CRUD), på funktionslager, funktionsuppsättningar och funktionsarkiventiteter. Detta är användbart vid kontinuerlig integrering och kontinuerlig leverans (CI/CD) eller GitOps-scenarier där CLI/YAML föredras.

Du behöver inte uttryckligen installera dessa resurser för den här handledningen, eftersom conda.yaml filen omfattar dem i konfigurationsinstruktionerna som visas här.

Så här förbereder du notebook-miljön för utveckling:

1. Klona lagringsplatsen azureml-examples till dina lokala GitHub resurser med det här kommandot:

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

   Du kan också ladda ned en zip-fil från lagringsplatsen azureml-examples . På den här sidan väljer du först listrutan code och sedan Download ZIP. Packa sedan upp innehållet i en mapp på den lokala enheten.

2. Ladda upp katalogen med exempel för feature store till projektarbetsytan

   1. I arbetsytan för Azure Machine Learning, öppna användargränssnittet för Azure Machine Learning Studio
   2. Välj Anteckningsböcker i den vänstra panelen
   3. Välj ditt användarnamn i kataloglistan
   4. Välj ellipser (...) och välj sedan Ladda upp mapp
   5. Välj mappen med funktionslagerexempel från den klonade katalogsökvägen: azureml-examples/sdk/python/featurestore-sample

3. Kör handledningen

   • Alternativ 1: Skapa en ny notebook-fil och kör anvisningarna i det här dokumentet steg för steg

   • Alternativ 2: Öppna en befintlig notebook-fil featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb. Du kan hålla det här dokumentet öppet och referera till det för mer förklarings- och dokumentationslänkar

     1. Välj Serverlös Spark Compute i den översta navigeringsrutan Beräkning . Den här åtgärden kan ta en till två minuter. Vänta tills ett statusfält längst upp visar Konfigurera session
     2. Välj Konfigurera session i det översta statusfältet
     3. Välj Python paket
     4. Välj Ladda upp conda-fil
     5. Välj fil azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml som finns på din lokala enhet
     6. (Valfritt) Öka tidsgränsen för sessionen (inaktiv tid i minuter) för att minska starttiden för serverlösa spark-kluster

4. Den här kodcellen startar Spark-sessionen. Det tar cirka 10 minuter att installera alla beroenden och starta Spark-sessionen.

   # 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. Konfigurera rotkatalogen för exemplen

   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. Konfigurera Azure Machine Learning CLI:

   • Installera Azure Machine Learning CLI-tillägget

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

   • Autentisera

     # authenticate
     !az login

   • Ange standardprenumerationen

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

   Anteckning

   En funktionslagerarbetsyta har stöd för återanvändning av funktioner i olika projekt. En projektarbetsyta – den aktuella arbetsytan som används – utnyttjar funktioner från ett specifikt funktionslager för att träna och dra slutsatser om modeller. Många projektarbetsytor kan dela och återanvända samma funktionslagerarbetsyta.

Etablera nödvändiga resurser

Du kan skapa ett nytt Azure Data Lake Storage (ADLS) Gen2-lagringskonto och containrar, eller återanvända befintliga lagringskonto- och containerresurser för funktionsarkivet. I en verklig situation kan olika lagringskonton vara värdar för ADLS Gen2-containrarna. Båda alternativen fungerar beroende på dina specifika krav.

I den här självstudien skapar du tre separata lagringscontainrar i samma ADLS Gen2-lagringskonto:

• Källdata
• Offlinebutik
• Observationsdata

1. Skapa ett ADLS Gen2-lagringskonto för källdata, offlinelagring och observationsdata.

   1. Ange namnet på ett Azure Data Lake Storage Gen2 lagringskonto i följande kodexempel. Du kan köra följande kodcell med de angivna standardinställningarna. Du kan också åsidosätta standardinställningarna.

      ## 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. Den här kodcellen skapar ADLS Gen2-lagringskontot som definierats i kodcellen ovan.

      # 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. Den här kodcellen skapar en ny lagringscontainer för offlinelagring.

      # 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. Den här kodcellen skapar en ny lagringscontainer för källdata.

      # 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. Den här kodcellen skapar en ny lagringscontainer för observationsdata.

      # 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. Kopiera exempeldata som krävs för den här självstudieserien till de nyligen skapade lagringscontainrarna.

   1. Om du vill skriva data till lagringscontainrarna, se till att Contributor och Storage Blob Data Contributor rollerna är tilldelade till användaridentiteten på det skapade ADLS Gen2-lagringskontot i Azure-portalen följande dessa steg.

      Viktigt!

      När du har kontrollerat att rollerna Deltagare och Lagringsblobdatadeltagare har tilldelats till användaridentiteten väntar du några minuter efter rolltilldelningen för att tillåta att behörigheter sprids innan du fortsätter med nästa steg. Mer information om åtkomstkontroll finns i role-baserad åtkomstkontroll (RBAC) för Azure lagringskonton

      Nästa kodceller kopierar exempelkälladata för transaktionsfunktionsuppsättningen som används i den här självstudien från ett offentligt lagringskonto till det nyligen skapade lagringskontot.

      # 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. För kontofunktionsuppsättningen som används i denna självstudie, kopiera exempelkälldata för kontofunktionen till det lagringskonto som just skapats.

      # 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. Kopiera exempelobservationsdata som används för träning från ett offentligt lagringskonto till det nyligen skapade lagringskontot.

      # 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. Kopiera exempelobservationsdata som används för batchinferens från ett offentligt lagringskonto till det nyligen skapade lagringskontot.

      # 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. Inaktivera åtkomsten till det offentliga nätverket på det nyligen skapade lagringskontot.

   1. Den här kodcellen inaktiverar åtkomst till offentligt nätverk för ADLS Gen2-lagringskontot som skapades tidigare.

      # 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. Ange ARM-ID:er för offlinelagring, källdata och observationsdatacontainrar.

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

Skapa en feature store med aktiverad materialisering

Ange parametrarna för funktionslagret

Ange värden för feature store-namn, plats, prenumerations-ID, gruppnamn och ARM-ID, som visas i det här kodcellsexemplet:

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

Den här kodcellen genererar en YAML-specifikationsfil för ett funktionslager med materialisering aktiverat.

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

Skapa feature store

Den här kodcellen använder YAML-specifikationsfilen som genererades i föregående steg för att skapa ett funktionslager med materialisering aktiverat.

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

Initiera kärnklienten för Azure Machine Learning-feature store SDK

SDK-klienten som initieras i den här cellen underlättar utveckling och användning av funktioner:

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

Tilldela roller till användaridentitet i funktionsektionen

Följ de här anvisningarna för att hämta Microsoft Entra objekt-ID för din användaridentitet. Använd sedan ditt Microsoft Entra objekt-ID i nästa kommando för att tilldela rollen AzureML Dátový vedec till din användaridentitet på den skapade 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

Hämta standardlagringskontot och nyckelvalvet för feature store, och inaktivera offentlig nätverksåtkomst till de motsvarande resurserna.

Nästa kodcell returnerar funktionsarkivobjektet för följande steg.

fs = featurestore.feature_stores.get()

Den här kodcellen returnerar namnen på det standardlagringskonto och nyckelvalv som är kopplade till 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]

Den här kodcellen inaktiverar åtkomst till det offentliga nätverket till standardlagringskontot för funktionsarkivet.

# 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

Nästa cell skriver ut namnet på standardnyckelvalvet för feature store.

print(default_key_vault_name)

Inaktivera offentlig nätverksåtkomst för det standardnyckelvalv som skapades tidigare för feature store

• Öppna standardnyckelvalvet som du skapade i föregående cell i Azure portalen.
• Välj fliken Nätverk.
• Välj Inaktivera offentlig åtkomst och välj sedan Använd längst ned till vänster på sidan.

Aktivera det hanterade virtuella nätverket för funktionslagringsarbetsytan

Uppdatera funktionalitetshanteraren med nödvändiga utgående regler

Nästa kodcell skapar en YAML-specifikationsfil för de utgående regler som definierats för funktionsbutiken.

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

Den här kodcellen använder den genererade YAML-specifikationsfilen för att uppdatera funktionsarkivet.

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

Skapa privata slutpunkter för de definierade utgående reglerna

Ett provision-network kommando skapar privata slutpunkter från det hanterade virtuella nätverket, där materialiseringsjobbet körs till källan, offlinelagringen, observationsdata, standardlagringskontot och standardnyckelvalvet för funktionsarkivet. Det här kommandot kan behöva cirka 20 minuter för att slutföra.

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

Den här kodcellen bekräftar skapandet av privata slutpunkter som definierats av reglerna för utgående trafik.

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

Uppdatera det hanterade virtuella nätverket för projektarbetsytan

Uppdatera sedan det hanterade virtuella nätverket för projektarbetsytan. Hämta först prenumerations-ID, resursgrupp och arbetsytenamn för projektarbetsytan.

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

Uppdatera projektarbetsytan med nödvändiga regler för utgående trafik

Projektarbetsytan behöver åtkomst till dessa resurser:

• Källdata
• Offlinebutik
• Observationsdata
• Funktionsarkiv
• Standardlagringskonto för funktionsarkiv

Den här kodcellen uppdaterar projektarbetsytan med hjälp av den genererade YAML-specifikationsfilen med nödvändiga regler för utgående trafik.

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

Den här kodcellen uppdaterar projektarbetsytan med hjälp av den genererade YAML-specifikationsfilen med utgående regler.

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

Den här kodcellen bekräftar skapandet av privata slutpunkter som definierats av reglerna för utgående trafik.

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

Du kan också verifiera utgående regler från Azure-portalen. Gå till Nätverk från den vänstra panelen för projektarbetsytan och öppna sedan fliken Arbetsyta för hanterad utgående åtkomst .

Skapa en prototyp och utveckla en funktionsuppsättning för löpande sammansättning av transaktioner

Utforska transaktionernas källdata

# 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

Utveckla en funktionsuppsättning för transaktioner lokalt

En funktionsuppsättningsspecifikation är en fristående funktionsuppsättningsdefinition som kan utvecklas och testas lokalt.

Skapa följande sammansättningsfunktioner för rullande fönster:

• antal transaktioner över tre dagar
• transaktionsbelopp tredagarssumma
• transaktionsbelopp tre-dagars medelvärde
• antal transaktioner på sju dagar
• transaktionsbelopp sjudagarssumma
• transaktioner sju dagars genomsnitt

Granska kodfilen featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.py för funktionstransformation. Den här Spark-transformatorn utför den löpande aggregering som definierats för funktionerna.

Mer information om funktionsuppsättningen och transformeringarna finns i Vad är ett hanterat funktionsarkiv?

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

Exportera en funktionsuppsättningsspecifikation

Om du vill registrera en funktionsuppsättningsspecifikation med funktionsarkivet måste den specifikationen sparas i ett visst format.

Om du vill granska funktionsuppsättningsspecifikationen för genererade transaktioner öppnar du den här filen från filträdet för att visa specifikationen:

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

Specifikationen innehåller följande element:

• source: en referens till en lagringsresurs – i det här fallet en parquet-fil i en bloblagringsresurs
• features: en lista över funktioner och deras datatyper. Om du tillhandahåller transformeringskoden
• index_columns: anslutningsnycklarna som krävs för att komma åt värden från funktionsuppsättningen

Som en annan fördel med att bevara en funktionsuppsättningsspecifikation som en YAML-fil kan specifikationen vara versionskontrollerad. Läs mer om funktionsuppsättningsspecifikationen i dokumentet med funktionslagerentiteter på den översta nivån och YAML-referensen för funktionsuppsättningsspecifikationen.

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)

Registrera en feature store-entitet

Entiteter hjälper till att framtvinga användning av samma kopplingsnyckeldefinitioner i funktionsuppsättningar som använder samma logiska entiteter. Exempel på entiteter kan vara kontoentiteter, kundentiteter osv. Entiteter skapas vanligtvis en gång och återanvänds sedan i flera funktionsuppsättningar. Mer information finns i dokumentet om entiteter i funktionslagret på högsta nivån.

Den här kodcellen skapar en kontoentitet för 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

Registrera transaktionsfunktionerna med funktionslagret och starta ett materialiseringsjobb

Om du vill dela och återanvända en funktionsuppsättningstillgång måste du först registrera tillgången i funktionsarkivet. Registrering av funktionsuppsättningstillgångar erbjuder hanterade funktioner som versionshantering och materialisering. Den här självstudieserien beskriver dessa ämnen.

Funktionsuppsättningstillgången refererar till både funktionsuppsättningsspecifikationen som du skapade tidigare och andra egenskaper , till exempel inställningar för version och materialisering.

Skapa en funktionsuppsättning

Nästa kodcell använder en fördefinierad YAML-specifikationsfil för att skapa en funktionsuppsättning.

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

Den här kodcellen förhandsgranskar den nyligen skapade funktionsuppsättningen.

# 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

Skicka ett materialiseringsjobb för återfyllnad

Nästa kodcell definierar start- och sluttidsvärden för funktionsmaterialiseringsfönstret och skickar ett materialiseringsjobb för återfyllnad.

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

Den här kodcellen tillhandahåller <JOB_ID_FROM_PREVIOUS_COMMAND>, för att kontrollera statusen för återfyllnadsmaterialiseringsjobbet.

### Check the job status

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

Den här kodcellen visar alla materialiseringsjobb för den aktuella funktionsuppsättningen.

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

Bifoga Azure Cache for Redis som en onlinebutik

Skapa en Azure Cache for Redis

I nästa kodcell definierar du namnet på den Azure Cache for Redis som du vill skapa eller återanvända. Du kan också åsidosätta andra standardinställningar.

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

Du kan välja Redis-cachenivån (basic, standard eller premium). Du bör välja en SKU-familj som är tillgänglig för den valda cachenivån. Besök den här dokumentationsresursen för mer information om hur val av olika nivåer kan påverka cacheprestanda. Besök den här dokumentationsresursen för mer information om priser för olika SKU-nivåer och familjer i Azure Cache for Redis.

Kör följande kodcell för att skapa en Azure Cache for Redis med premiumnivå, SKU-familj P och cachekapacitet 2. Det kan ta cirka 5–10 minuter att skapa Redis-instansen.

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

Uppdatera funktionsarkivet med onlinebutiken

Koppla Azure Cache for Redis till funktionsarkivet för att använda det som materialiseringsarkiv online. Nästa kodcell skapar en YAML-specifikationsfil med utgående regler för onlinebutiken som definierats för funktionsarkivet.

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

Nästa kodcell uppdaterar funktionsarkivet med den genererade YAML-specifikationsfilen med utgående regler för onlinebutiken.

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

Uppdatera regler för utgående trafik i projektutrymme

Projektarbetsytan behöver åtkomst till onlinebutiken. Följande kodcell skapar en YAML-specifikationsfil med nödvändiga utgående regler för projektarbetsytan.

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)

Kör nästa kodcell för att uppdatera projektarbetsytan med den genererade YAML-specifikationsfilen med utgående regler för onlinebutiken.

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

Funktion för att materialisera transaktioner konfigurerad för nätbutik

Nästa kodcell möjliggör onlinematerialisering för funktionsuppsättningen transactions .

# 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

Nästa kodcell definierar start- och sluttiderna för funktionsmaterialiseringsfönstret och skickar ett materialiseringsjobb för återfyllnad.

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

Använda registrerade funktioner för att generera träningsdata

Importera observationsdata

Utforska först observationsdata. Kärndata som används för träning och slutsatsdragning omfattar vanligtvis observationsdata. Dessa data kopplas sedan till funktionsdata för att skapa en fullständig träningsdataresurs. Observationsdata är de data som samlas in under tidpunkten för händelsen. I det här fallet har den grundläggande transaktionsdata, inklusive transaktions-ID, konto-ID och transaktionsbeloppsvärden. Eftersom observationsdata används för träning har den även målvariabeln tillagd (is_fraud).

observation_data_path = f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/train/*.parquet"
observation_data_df = spark.read.parquet(observation_data_path)
obs_data_timestamp_column = "timestamp"

display(observation_data_df)
# Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

Hämta den registrerade funktionsuppsättningen och visa en lista över dess funktioner

Hämta sedan en funktionsuppsättning genom att ange dess namn och version och sedan lista funktioner i den här funktionsuppsättningen. Skriv också ut några exempel på funktionsvärden.

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

Välj funktioner och generera träningsdata

Välj funktioner för träningsdata och använd funktionsarkivets SDK för att generera träningsdata.

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

En tidsbestämd koppling har tillfört funktionerna till träningsdatan.

Valfria nästa steg

Nu när du har skapat en säker funktionsdatabas och skickat en lyckad materialiseringsprocess kan du gå igenom handledningsserien för att bygga en förståelse för funktionsdatabasen.

Den här självstudien innehåller en blandning av steg från Självstudier 1 och 2 i den här serien. Kom ihåg att ersätta nödvändiga offentliga lagringscontainrar som används i de andra självstudierna med de som skapats i den här självstudieboken för nätverksisolering.

Detta avslutar självstudien. Dina träningsdata använder funktioner från ett funktionslager. Du kan antingen spara den i lagring för senare användning eller köra modellträning direkt på den.

Nästa steg

• Självstudie 2: Experimentera och träna modeller med hjälp av funktioner
• Självstudie 3: Aktivera återkommande materialisering och köra batchinferens