Condividi tramite

Esercitazione 6: Isolamento della rete con Feature Store

Un archivio di funzionalità gestito Azure Machine Learning consente di individuare, creare e rendere operative le funzionalità. Le funzionalità fungono da tessuto connettivo nel ciclo di vita del Machine Learning, a partire dalla fase di creazione dei prototipi, in cui si sperimentano diverse funzionalità. Questo ciclo di vita continua con la fase di operazionalizzazione, in cui vengono distribuiti i modelli e vengono eseguiti i passaggi di inferenza per cercare i dati delle funzionalità. Per altre informazioni sui feature store, leggere il documento Concetti relativi ai feature store.

Importante

cache di Azure per Redis ha annunciato il piano di ritiro per tutte le SKU. È consigliabile spostare le istanze di cache di Azure per Redis esistenti in Azure Redis gestito non appena possibile.

Linee guida per la migrazione:

Per altre informazioni sul ritiro:

Questa esercitazione descrive come configurare l'ingresso sicuro tramite un endpoint privato e come proteggere l'uscita tramite una rete virtuale gestita.

La prima parte di questa serie di esercitazioni ha illustrato come creare una specifica del set di funzionalità con trasformazioni personalizzate e usare tale set di funzionalità per generare dati di training. La parte 2 della serie ha illustrato come abilitare la materializzazione ed eseguire un back-fill. Inoltre, la parte 2 ha illustrato come sperimentare le funzionalità, come metodo per migliorare le prestazioni del modello. La parte 3 ha illustrato come un archivio delle funzionalità aumenti l'agilità nei flussi di sperimentazione e training. La Parte 3 ha anche descritto come eseguire l'inferenza batch. La quarta esercitazione ha illustrato come usare il feature store per casi d'uso di inferenza online/in tempo reale. La quinta esercitazione ha illustrato come sviluppare un set di funzionalità con un'origine dati personalizzata. La sesta esercitazione illustra come

  • Configurare le risorse necessarie per l'isolamento di rete di un archivio delle funzionalità gestito.
  • Creare una nuova risorsa del feature store.
  • Configurare il feature store per supportare scenari di isolamento della rete.
  • Aggiornare l'area di lavoro del progetto (area di lavoro corrente) per supportare scenari di isolamento della rete.

Prerequisiti

Nota

Questa esercitazione usa un notebook Azure Machine Learning con Serverless Spark Compute.

  • Un'area di lavoro Azure Machine Learning abilitata con rete virtuale gestita per i processi Spark serverless

  • Per configurare l'area di lavoro del progetto:

    1. Creare un file YAML denominato network.yml:

      managed_network:
isolation_mode: allow_internet_outbound

    2. Eseguire questi comandi per aggiornare l'area di lavoro e preparare la rete virtuale gestita per i processi Spark serverless.

      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

    Per ulteriori informazioni, visitare Configurazione per processi Spark serverless.

  • L'account utente deve avere il ruolo Owner o Contributor assegnato al gruppo di risorse in cui si crea l'archivio funzionalità. Anche il tuo account utente deve avere il ruolo User Access Administrator.

Importante

Per l'area di lavoro Azure Machine Learning, impostare isolation_mode su allow_internet_outbound. Questa è l'unica modalità di isolamento rete supportata. Questa esercitazione illustra come connettersi a origini, archivi di materializzazione e dati di osservazione in modo sicuro tramite endpoint privati.

Impostazione

Questa esercitazione utilizza il core SDK del feature store di Python (azureml-featurestore). L'SDK di Python viene usato solo per lo sviluppo e il test dei set di funzionalità. L'interfaccia a riga di comando (CLI) viene utilizzata per operazioni CRUD (creazione, lettura, aggiornamento ed eliminazione) su feature store, set di feature e entità del feature store. Ciò è utile negli scenari di integrazione continua e recapito continuo (CI/CD) o GitOps in cui l'interfaccia della riga di comando/YAML è preferibile.

Non è necessario installare in modo esplicito queste risorse per questa esercitazione, perché nelle istruzioni di configurazione illustrate di seguito, il file conda.yaml li copre.

Per preparare l'ambiente notebook per lo sviluppo:

  1. Clonare il repository azureml-examples nelle risorse GitHub locali con questo comando:

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

    È anche possibile scaricare un file ZIP dal repository azureml-examples. In questa pagina, selezionare prima l'elenco a discesa code e quindi Download ZIP. Quindi, decomprimere il contenuto in una cartella nel dispositivo locale.

  2. Caricare la directory degli esempi del feature store nell'area di lavoro del progetto.

    1. Nell'area di lavoro Azure Machine Learning aprire l'interfaccia utente studio di Azure Machine Learning
    2. Selezionare Notebook nel pannello sinistro
    3. Seleziona il nome utente nella lista della directory
    4. Selezionare i puntini di sospensione (...) e quindi Carica cartella
    5. Selezionare la cartella degli esempi dal feature store dal percorso della directory clonata: azureml-examples/sdk/python/featurestore-sample

  3. Eseguire l'esercitazione

    • Opzione 1: Creare un nuovo notebook ed eseguire le istruzioni contenute in questo documento, passo dopo passo

    • Opzione 2: aprire il notebook featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb esistente. È possibile mantenere aperto questo documento e farvi riferimento per ottenere altre informazioni e collegamenti a documentazione

      1. Nella casella a discesa Calcolo nella barra di navigazione in alto, selezionare Serverless Spark. L'operazione potrebbe richiedere uno o due minuti. Attendere che una barra di stato compaia nella parte superiore con la dicitura: Configura sessione
      2. Selezionare Configura sessione sulla barra di stato in alto
      3. Selezionare Python pacchetti
      4. Seleziona Carica file Conda
      5. Selezionare il file azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml che si trova nel dispositivo locale
      6. (Facoltativo) Aumentare il timeout della sessione (tempo di inattività in minuti) per ridurre il tempo di avvio del cluster Spark serverless

  4. Questa cella di codice avvia la sessione Spark. Sono necessari circa 10 minuti per installare tutte le dipendenze e avviare la sessione Spark.

    # 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. Configurare la directory principale per gli esempi

    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. Configurare l'interfaccia della riga di comando di Azure Machine Learning:

    • Installare l'estensione dell'interfaccia della riga di comando di Azure Machine Learning

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

    • Autenticare

      # authenticate
!az login

    • Impostare la sottoscrizione predefinita

      # Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id

    Nota

    Un'area di lavoro dell'archivio delle funzionalità supporta il riutilizzo delle funzionalità tra i progetti. Un'area di lavoro del progetto, l'area di lavoro corrente in uso, sfrutta le funzionalità di un archivio delle funzionalità specifico per eseguire il training e l'inferenza dei modelli. Molte aree di lavoro del progetto possono condividere e riutilizzare la stessa area di lavoro dell'archivio delle funzionalità.

Fornire le risorse necessarie

È possibile creare un nuovo account di archiviazione e contenitori di Azure Data Lake Storage (ADLS) Gen2 oppure riutilizzare l'account di archiviazione e le risorse del contenitore esistenti per l'archivio funzionalità. In una situazione reale, diversi account di archiviazione possono ospitare i contenitori ADLS Gen2. Entrambe le opzioni funzionano, a seconda dei requisiti specifici.

Per questa esercitazione vengono creati tre diversi contenitori di archiviazione nello stesso account di archiviazione di ADLS Gen2:

  • Dati di origine
  • Negozio offline
  • Dati di osservazione

  1. Creare un account di archiviazione DILS Gen2 per i dati di origine, l'archivio offline e i dati di osservazione.

    1. Specificare il nome di un account di archiviazione Azure Data Lake Storage Gen2 nell'esempio di codice seguente. È possibile eseguire la seguente cella di codice con le impostazioni predefinite specificate. Facoltativamente, è possibile eseguire l'override delle impostazioni predefinite.

      ## 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. Questa cella di codice crea l'account di archiviazione di Azure Data Lake Storage Gen2 definito nella cella di codice precedente.

      # 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. Questa cella di codice crea un nuovo contenitore di archiviazione per l'archiviazione offline.

      # 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. Questa cella di codice crea un nuovo contenitore di archiviazione per i dati di origine.

      # 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. Questa cella di codice crea un nuovo contenitore di archiviazione per i dati di osservazione.

      # 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. Copiare i dati campione necessari per questa serie di esercitazioni nei contenitori di archiviazione appena creati.

    1. Per scrivere dati nei contenitori di archiviazione, assicurarsi che i ruoli Contributor e Storage Blob Data Contributor siano assegnati all'identità utente nell'account di archiviazione ADLS Gen2 creato nel portale di Azure seguendo questa procedura.

      Importante

      Quando si è verificato che i ruoli Collaboratore e Collaboratore per dati dei BLOB di archiviazione siano assegnati all'identità utente, attendere alcuni minuti dopo l'assegnazione del ruolo per consentire la propagazione delle autorizzazioni prima di procedere con i passaggi successivi. Per altre informazioni sul controllo di accesso, vedere role-based access control (RBAC) per gli account di archiviazione Azure

      Le celle di codice successive copiano i dati di origine di esempio per i set di funzionalità delle transazioni usati in questa esercitazione da un account di archiviazione pubblico a quello appena creato.

      # 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. Per la configurazione di funzionalità dell'account utilizzata in questo tutorial, copia i dati di origine di esempio per la configurazione di funzionalità dell'account nel nuovo account di archiviazione creato.

      # 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. Copiare i dati di osservazione di esempio usati per il training da un account di archiviazione pubblico a quello appena creato.

      # 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. Copiare i dati di osservazione di esempio usati per l'inferenza batch da un account di archiviazione pubblico a quello appena creato.

      # 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. Disabilitare l'accesso alla rete pubblica nell'account di archiviazione appena creato.

    1. Questa cella di codice disabilita l'accesso alla rete pubblica per l'account di archiviazione ADLS Gen2 appena creato.

      # 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. Impostare GLI ID ARM per l'archivio offline, i dati di origine e i contenitori di dati di osservazione.

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

Crea un feature store con materializzazione abilitata

Impostare i parametri dell'archivio funzionalità

Impostare il nome del Feature Store, la sua posizione, l'ID della sottoscrizione, il nome del gruppo e i valori dell'ID ARM, come illustrato in questo esempio di cella di codice.

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

Questa cella di codice genera un file di specifica YAML per uno store delle funzionalità con materializzazione abilitata.

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

Creare il feature store

Questa cella di codice usa il file di specifica YAML generato nel passaggio precedente per creare un archivio delle funzionalità con materializzazione abilitata.

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

Inizializzare il client dell'SDK principale dell'archivio di funzionalità di Azure Machine Learning

Il client SDK inizializzato in questa cella facilita lo sviluppo e l'utilizzo delle funzionalità:

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

Assegnare ruoli all'identità utente nel feature store

Seguire queste istruzioni per ottenere l'ID oggetto di Microsoft Entra per l'identità utente. Quindi, utilizza l'ID oggetto Microsoft Entra nel comando successivo per assegnare il ruolo AzureML Scienziato dei dati all'identità utente nel feature store creato.

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

Ottenere l'account di archiviazione predefinito e il key vault per lo store di funzionalità e disabilitare l'accesso alla rete pubblica per le risorse corrispondenti.

La cella di codice successiva restituisce l'oggetto del feature store per i passaggi successivi.

fs = featurestore.feature_stores.get()

Questa cella di codice restituisce i nomi dell'account di archiviazione predefinito e del Key Vault per il repository delle funzionalità.

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

Questa cella di codice disabilita l'accesso alla rete pubblica per l’account di archiviazione predefinito per il feature store.

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

La cella successiva stampa il nome del Key Vault predefinito per il feature store.

print(default_key_vault_name)

Disabilitare l'accesso alla rete pubblica per il key vault del feature store predefinito creato in precedenza

  • Nel portale di Azure, apri l'insieme di credenziali predefinito che hai creato in precedenza.
  • Selezionare la scheda Rete.
  • Selezionare Disabilita accesso pubblico e quindi Applica in basso a sinistra nella pagina.

Abilitare la rete virtuale gestita per l'area di lavoro del negozio di funzionalità

Aggiornare il feature store con le regole in uscita necessarie

La cella di codice successiva crea un file di specifiche YAML per le regole di uscita definite per il data store delle feature.

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

Questa cella di codice usa il file di specifica YAML generato per aggiornare l'archivio delle funzionalità.

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

Creare endpoint privati per le regole in uscita definite

Un comando provision-network crea endpoint privati dalla rete virtuale gestita, nel contesto in cui vengono eseguiti i job di materializzazione per l'origine, lo store offline, i dati di osservazione, l'account di archiviazione predefinito e il key vault predefinito per il feature store. Il completamento di questo comando potrebbe richiedere circa 20 minuti.

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

Questa cella di codice conferma la creazione di endpoint privati definiti dalle regole in uscita.

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

Aggiornare la rete virtuale gestita per l'area di lavoro del progetto

Il prossimo passaggio consiste nell’aggiornare la rete virtuale gestita per l'area di lavoro del progetto. Per prima cosa, ottenere l'ID della sottoscrizione, il gruppo di risorse e il nome dell'area di lavoro per lo spazio di lavoro del progetto.

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

Aggiorna l'area di lavoro del progetto con le regole di uscita necessarie.

L'area di lavoro del progetto deve poter accedere a queste risorse:

  • Dati di origine
  • Negozio offline
  • Dati di osservazione
  • Archivio delle caratteristiche
  • Account di archiviazione predefinito del feature store

Questa cella di codice aggiorna l'area di lavoro del progetto usando il file di specifica YAML generato con le regole in uscita necessarie.

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

Questa cella di codice aggiorna l'area di lavoro del progetto usando il file di specifica YAML generato con le regole in uscita.

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

Questa cella di codice conferma la creazione di endpoint privati definiti dalle regole in uscita.

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

È anche possibile verificare le regole in uscita dal portale di Azure. Passare a Rete dal pannello sinistro per l'area di lavoro del progetto e quindi aprire la scheda Accesso in uscita gestito dell'area di lavoro.

Questo screenshot mostra le regole in uscita per un'area di lavoro di progetto in Azure portal.

Creare un prototipo e sviluppare un set di funzionalità delle transazioni con aggregazione regolare

Esplorare i dati di origine delle transazioni

Nota

Un contenitore BLOB accessibile pubblicamente ospita i dati campione usati in questa esercitazione. Può essere letto solo in Spark tramite driver wasbs. Quando si creano insiemi di funzionalità utilizzando dati di origine personalizzati, ospitarli in un account ADLS Gen2 e utilizzare un driver abfss nel percorso dati.

# 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

Sviluppare in locale un set di funzionalità di transazioni

Una specifica del set di funzionalità è una definizione di set di funzionalità autonoma che può essere sviluppata e testata localmente.

Crea le seguenti caratteristiche di aggregazione di finestra mobile:

  • conteggio delle transazioni di tre giorni
  • importo totale delle transazioni di tre giorni
  • media dell‘importo delle transazioni di tre giorni
  • conteggio delle transazioni di sette giorni
  • somma degli importi delle transazioni degli ultimi sette giorni
  • media dell’importo delle transazioni di sette giorni

Esaminare il file di codice di trasformazione delle funzionalità featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.py. Questo trasformatore spark esegue l'aggregazione regolare definita per le funzionalità.

Per informazioni più dettagliate sul set di funzionalità e sulle trasformazioni, vedere Concetti relativi all'archivio delle funzionalità.

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

Esportare una specifica del set di funzionalità

Per registrare una specifica del set di funzionalità con il repository di funzionalità, tale specifica deve essere salvata in un formato specifico.

Per visualizzare la specifica del set di funzionalità delle transazioni generate, aprire questo file dall'albero dei file.

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

La specifica contiene questi elementi:

  • source: riferimento a una risorsa di archiviazione (in questo caso, un file Parquet in una risorsa di archiviazione BLOB)
  • features: elenco di funzionalità e dei relativi tipi di dati. Se si fornisce codice di trasformazione
  • index_columns: le chiavi di join necessarie per accedere ai valori dal set di funzionalità

Un altro vantaggio della persistenza di una specifica del set di funzionalità come file YAML è che essa può essere controllata dalla versione. Per ulteriori informazioni sulla specifica del set di funzionalità, consultare il documento relativo alle entità dell'archivio delle funzionalità di primo livello e il riferimento YAML delle specifiche del set di funzionalità.

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)

Registrare un'entità del feature store

Le entità consentono di applicare l'uso delle stesse definizioni di chiave di join tra set di funzionalità che usano le stesse entità logiche. Gli esempi di entità possono includere entità account, entità cliente e così via. Le entità vengono in genere create una sola volta e quindi riutilizzate tra set di funzionalità. Per altre informazioni, vedere il documento relativo alle entità dell'archivio delle funzionalità di primo livello.

Questa cella di codice crea un'entità account per il 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

Registrare l'insieme di funzionalità di transazione nella memoria delle funzionalità e avviare un'attività di materializzazione.

Per condividere e riutilizzare un asset del set di funzionalità, è prima necessario registrare tale asset con l'archivio funzionalità. La registrazione degli asset del set di funzionalità offre funzionalità gestite, tra cui il controllo delle versioni e la materializzazione. Questa serie di esercitazioni tratta questi argomenti.

L'asset del set di funzionalità fa riferimento sia alla specifica del set di funzionalità creata in precedenza che ad altre proprietà, ad esempio le impostazioni di materializzazione e versione.

Creazione di un set di funzioni

La cella di codice successiva usa un file di specifica YAML predefinito per creare un set di funzionalità.

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

Questa cella di codice visualizza l'anteprima del set di funzionalità appena creato.

# 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

Invia un processo di compensazione di materializzazione

La cella di codice successiva definisce i valori dell'ora di inizio e di fine per la finestra di materializzazione delle caratteristiche e avvia un'operazione di materializzazione retroattiva.

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

Questa cella di codice fornisce <JOB_ID_FROM_PREVIOUS_COMMAND> per controllare lo stato del processo di materializzazione del backfill.

### Check the job status

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

Questa cella di codice elenca tutti i processi di materializzazione per il set di funzionalità corrente.

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

Allegare cache di Azure per Redis come negozio online

Crea un cache di Azure per Redis

Nella cella di codice successiva definire il nome del cache di Azure per Redis che si desidera creare o riutilizzare. Facoltativamente, è possibile eseguire l'override di altre impostazioni predefinite.

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

È possibile selezionare il livello di cache Redis (Basic, Standard o Premium). È consigliabile scegliere una famiglia di SKU disponibile per il livello di cache selezionato. Visitare questa risorsa di documentazione per altre informazioni sul modo in cui la selezione di livelli diversi può influire sulle prestazioni della cache. Visitare questa risorsa di documentazione per altre informazioni sui prezzi per diversi livelli sku e famiglie di cache di Azure per Redis.

Eseguire la cella di codice seguente per creare un cache di Azure per Redis con il livello Premium, la famiglia di SKU P e la capacità della cache 2. Il processo di provisioning dell'istanza di Redis può richiedere circa 5-10 minuti.

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

Aggiornare l'archivio delle funzionalità con l'archivio online

Collegare cache di Azure per Redis all'archivio delle funzionalità per usarlo come archivio di materializzazione online. La cella di codice successiva crea un file di specifica YAML con regole di uscita per l'archivio online, definite per il store delle funzionalità.

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

La cella di codice successiva aggiorna il feature store con il file di specifica YAML generato con le regole di uscita per il negozio online.

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

Aggiornare le regole in uscita dell'area di lavoro del progetto

L'area di lavoro del progetto deve poter accedere allo store online. La cella di codice seguente crea un file di specifica YAML con le regole in uscita necessarie per l'area di lavoro del progetto.

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)

Eseguire la prossima cella di codice per aggiornare l'area di lavoro del progetto con il file di specifica YAML generato con le regole di uscita per il negozio online.

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

Materializzare l'insieme di funzionalità delle transazioni nel negozio online

La cella di codice successiva abilita la materializzazione online per il set di funzionalità 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

La cella di codice successiva definisce l'ora di inizio e di fine per la finestra di materializzazione delle funzionalità e invia un processo di materializzazione back-fill.

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

Usare le funzionalità registrate per generare dati di training

Caricare i dati di osservazione

Prima di tutto, esplorare i dati di osservazione. In genere, i dati di base usati per il training e l'inferenza includono dati di osservazione. Tali dati vengono quindi uniti ai dati delle funzionalità per creare una risorsa dati di training completa. I dati di osservazione sono i dati acquisiti durante il tempo dell'evento. In questo caso, ha dati principali della transazione, inclusi l'ID della transazione, l'ID dell'account e l'importo della transazione. In questo caso, poiché i dati di osservazione vengono usati per l'addestramento, includono anche la variabile di destinazione aggiunta (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

Ottenere il set di funzionalità registrato ed elencarne le funzionalità

Quindi, ottenere un set di funzionalità specificandone il nome e la versione, e poi elencarne le funzionalità. Stampare anche alcuni valori di funzionalità campione.

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

Selezionare le funzionalità e generare dati di training

Selezionare le caratteristiche per i dati di addestramento e usare l'SDK del feature store per generare i dati di addestramento.

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

Un join temporizzato ha aggiunto le funzionalità ai dati di training.

Passaggi successivi facoltativi

Dopo aver creato correttamente un archivio delle funzionalità sicuro e inviato un'esecuzione di materializzazione riuscita, è possibile completare la serie di esercitazioni per acquisire familiarità con l’archivio delle funzionalità.

Questa esercitazione contiene una combinazione di passaggi delle esercitazioni 1 e 2 di questa serie. Ricorda di sostituire i contenitori di archiviazione pubblici necessari usati nei notebook degli altri esercitazioni con quelli creati nel notebook di questa esercitazione, per l'isolamento della rete.

Qui si conclude l'esercitazione. I dati di addestramento usano feature da un feature store. È possibile salvarlo nello storage per usarlo in un secondo momento, oppure eseguire direttamente l'addestramento del modello.

Passaggi successivi

  • Last updated on