Dela via

Självstudie 6: Nätverksisolering med funktionsarkiv

Med en Azure Machine Learning-hanterad funktionsbutik 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 funktionslager finns i dokumentet koncept för 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.

Del 1 i den här självstudieserien visade hur du skapar en funktionsuppsättningsspecifikation med anpassade transformeringar och använder den funktionsuppsättningen för att generera träningsdata. Del 2 i serien visade hur du aktiverar materialisering och utför en återfyllnad. Dessutom visade del 2 hur du experimenterar med funktioner som ett sätt att förbättra modellprestandan. Del 3 visade hur ett funktionslager ökar flexibiliteten i experimenterings- och träningsflödena. I del 3 beskrivs också hur du kör batchinferens. Självstudie 4 beskriver hur du använder funktionsarkivet för användningsfall för online-/realtidsinferens. Självstudie 5 visade hur du utvecklar en funktionsuppsättning med en anpassad datakälla. Självstudie 6 visar hur du gör

  • Konfigurera nödvändiga resurser för nätverksisolering av en hanterad funktionsbutik.
  • Skapa en ny funktionslagerresurs.
  • Konfigurera funktionsarkivet för att stödja scenarier för nätverksisolering.
  • Uppdatera din projektarbetsyta (aktuell arbetsyta) för att stödja scenarier för nätverksisolering .

Förutsättningar

Kommentar

I den här självstudien används en Azure Machine Learning-notebook-fil med serverlös Spark Compute.

  • 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 Owner rollen eller Contributor tilldelad till resursgruppen där du skapar funktionsarkivet. Ditt användarkonto behöver User Access Administrator också rollen.

Viktigt!

För din Azure Machine Learning-arbetsyta anger du isolation_mode till allow_internet_outbound. Detta är det enda nätverksisoleringsläge som stöds. Den här självstudien visar hur du ansluter till källor, materialiseringslager och observationsdata på ett säkert sätt via privata slutpunkter.

Konfigurera

I den här självstudien används SDK:et för Python-funktionsarkivets kärnor (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 självstudien, eftersom filen omfattar dem i de konfigurationsinstruktioner som visas här conda.yaml .

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 code först listrutan och väljer Download ZIPsedan . Packa sedan upp innehållet i en mapp på den lokala enheten.

  2. Ladda upp exempelkatalogen för funktionsarkivet till projektarbetsytan

    1. Öppna användargränssnittet för Azure Machine Learning-studio i Azure Machine Learning-arbetsytan
    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 självstudien

    • 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

    Kommentar

    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
  • Offlinearkiv
  • 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 kontrollerar du att rollerna Deltagare och Lagringsblobdatadeltagare tilldelas till användaridentiteten på det skapade ADLS Gen2-lagringskontot i Azure Portal genom att följa 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 rollbaserad åtkomstkontroll (RBAC) för Azure Storage-konton

      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 den här självstudien kopierar du exempelkällans data för kontofunktionen som angetts till det nyligen skapade lagringskontot.

      # 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 ett funktionslager med materialisering aktiverat

Ange parametrarna för funktionsarkivet

Ange värden för funktionsarkivets namn, plats, prenumerations-ID, gruppnamn och ARM-ID enligt 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 funktionsarkivet

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 Azure Machine Learning-funktionsarkivets SDK-klient

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 funktionsarkivet

Följ de här anvisningarna för att hämta Microsoft Entra-objekt-ID:t för din användaridentitet. Använd sedan ditt Microsoft Entra-objekt-ID i nästa kommando för att tilldela Rollen AzureML Dataforskare till din användaridentitet i det skapade funktionsarkivet.

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 funktionsarkivet och inaktivera åtkomst till det offentliga nätverket till motsvarande resurser

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

fs = featurestore.feature_stores.get()

Den här kodcellen returnerar namnen på standardlagringskontot och nyckelvalvet för funktionsarkivet.

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

print(default_key_vault_name)

Inaktivera åtkomsten till det offentliga nätverket för standardnyckelvalvet för funktionsarkivet som skapades tidigare

  • Öppna standardnyckelvalvet som du skapade i föregående cell i Azure Portal.
  • 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 funktionsarkivet med nödvändiga regler för utgående trafik

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

# 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
  • Offlinearkiv
  • 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 de utgående reglerna från Azure Portal. Gå till Nätverk från den vänstra panelen för projektarbetsytan och öppna sedan fliken Arbetsyta för hanterad utgående åtkomst .

Den här skärmbilden visar regler för utgående trafik för en projektarbetsyta i Azure Portal.

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

Utforska transaktionernas källdata

Kommentar

En offentligt tillgänglig blobcontainer är värd för de exempeldata som används i den här självstudien. Det kan bara läsas i Spark via wasbs drivrutin. När du skapar funktionsuppsättningar med dina egna källdata ska du vara värd för dem i ett ADLS Gen2-konto och använda en abfss drivrutin i datasökvägen.

# 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 med tre dagar
  • transaktionsbelopp tredagarssumma
  • transaktionsbelopp med tre dagars genomsnitt
  • antal transaktioner på sju dagar
  • transaktionsbelopp sjudagarssumma
  • transaktioner uppgår till sju dagars genomsnitt

Granska kodfilen featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.pyför funktionstransformering . 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 funktionsarkivkoncept.

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 anger transformeringskod
  • 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 funktionslagerentitet

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 med funktionslagerentiteter på den översta nivån.

Den här kodcellen skapar en kontoentitet för funktionsarkivet.

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 transaktionsfunktionen med funktionsarkivet och skicka 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 tillgångsuppsättningar 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 innehåller <JOB_ID_FROM_PREVIOUS_COMMAND>, för att kontrollera statusen för återfyllnadsmaterialetiseringsjobbet.

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

Anslut 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 projektarbetsyta

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

Materialisera transaktionsfunktionen inställd på onlinebutik

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

Läsa in 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 punkt-i-tid-koppling har bifogat funktionerna till träningsdata.

Valfria nästa steg

Nu när du har skapat ett säkert funktionsarkiv och skickat en lyckad materialiseringskörning kan du gå igenom självstudieserien för att skapa en förståelse för funktionsarkivet.

Den här självstudien innehåller en blandning av steg från självstudierna 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