Partager via

Tutoriel 6 : Isolement réseau avec le magasin de fonctionnalités

Le magasin de fonctionnalités géré d’Azure Machine Learning vous permet de découvrir, créer et opérationnaliser des fonctionnalités. Les fonctionnalités sont le tissu conjonctif du cycle de vie du Machine Learning, à commencer par la phase de prototypage, où vous expérimentez diverses fonctionnalités. Ce cycle de vie continue par la phase d’opérationnalisation, où vous déployez vos modèles, et les étapes d’inférence qui recherchent les données des fonctionnalités. Pour plus d’informations sur les magasins de fonctionnalités, consultez le document sur les concepts du magasin de fonctionnalités .

Ce tutoriel explique comment configurer une entrée sécurisée avec un point de terminaison privé et une sortie sécurisée avec un réseau virtuel managé.

La partie 1 de cette série de tutoriels vous a montré comment créer une spécification d’ensemble de fonctionnalités avec des transformations personnalisées et comment utiliser un ensemble de fonctionnalités pour générer des données de formation. La partie 2 de la série a montré comment activer la matérialisation et effectuer un remplissage. En outre, la partie 2 a montré comment expérimenter des fonctionnalités, comme un moyen d’améliorer les performances du modèle. La partie 3 a montré comment un magasin de fonctionnalités permet d’accroître l’agilité des flux d’expérimentation et d’entraînement. La partie 3 a également décrit comment exécuter l’inférence par lots. Le tutoriel 4 vous a montré comment utiliser le magasin de fonctionnalités pour les cas d’usage d’inférence en ligne/en temps réel. Le tutoriel 5 a montré comment développer un ensemble de fonctionnalités avec une source de données personnalisée. Le tutoriel 6 montre comment

  • Configurer les ressources nécessaires pour l’isolement réseau d’un magasin de caractéristiques géré.
  • Créer une ressource de magasin de caractéristiques.
  • Configurer votre magasin de caractéristiques pour prendre en charge les scénarios d’isolement réseau.
  • Mettre à jour votre espace de travail de projet (espace de travail actuel) pour prendre en charge les scénarios d’isolement réseau.

Prérequis

Remarque

Ce tutoriel utilise un notebook Azure Machine Learning avec le calcul Spark serverless.

  • Un espace de travail Azure Machine Learning, activé avec un réseau virtuel managé pour les travaux Spark serverless

  • Pour configurer l’espace de travail de votre projet :

    1. Créez un fichier YAML nommé network.yml :

      managed_network:
isolation_mode: allow_internet_outbound

    2. Exécutez ces commandes pour mettre à jour l’espace de travail et provisionner le réseau virtuel managé pour les travaux 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

    Pour plus d’informations, consultez Configuration pour un travail Spark serverless.

  • Votre compte d’utilisateur doit avoir le rôle Owner ou Contributor attribué sur le groupe de ressources où vous créez le magasin de caractéristiques. Votre compte d’utilisateur a également besoin du rôle User Access Administrator.

Important

Pour votre espace de travail Azure Machine Learning, définissez isolation_mode sur allow_internet_outbound. Il s’agit du seul mode d’isolement réseau pris en charge. Ce tutoriel montre comment se connecter aux sources, au magasin de matérialisation et aux données d’observation de manière sécurisée en utilisant des points de terminaison privés.

Configurer

Ce tutoriel utilise le SDK de base du magasin de caractéristiques Python (azureml-featurestore). Le SDK Python est utilisé pour le développement et le test uniquement des ensembles de caractéristiques. L’interface CLI est utilisée pour les opérations de création, de lecture, de mise à jour et de suppression (CRUD) sur des magasins de caractéristiques, des ensembles de caractéristiques et des entités de magasin de caractéristiques. C’est utile dans les scénarios d’intégration continue et livraison continue (CI/CD) ou GitOps, où CLI/YAML est préférable.

Vous n’avez pas besoin d’installer explicitement ces ressources pour ce tutoriel, car dans les instructions de configuration indiquées ici, le fichier conda.yaml s’en charge.

Pour préparer l’environnement de notebook pour le développement :

  1. Clonez le référentiel azureml-examples sur vos ressources GitHub locales avec cette commande :

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

    Vous pouvez aussi télécharger un fichier zip à partir du référentiel azureml-examples. Dans cette page, sélectionnez d’abord la liste déroulante code, puis sélectionnez Download ZIP. Ensuite, décompressez le contenu dans un dossier sur votre appareil local.

  2. Chargez le répertoire des exemples de magasin de fonctionnalités dans l’espace de travail du projet

    1. Dans l’espace de travail Azure Machine Learning, ouvrez l’interface utilisateur Azure Machine Learning Studio
    2. Sélectionnez Notebooks dans le volet gauche.
    3. Sélectionnez votre nom d’utilisateur dans la liste des répertoires.
    4. Sélectionnez les points de suspension (...), puis sélectionnez Charger le dossier
    5. Sélectionnez le dossier des exemples de magasin de caractéristiques dans le chemin du répertoire cloné : azureml-examples/sdk/python/featurestore-sample

  3. Exécuter le tutoriel

    • Option 1 : Créez un notebook et exécutez les instructions de ce document étape par étape

    • Option 2 : Ouvrez le notebook featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb existant. Vous pouvez laisser ce document ouvert et le consulter pour obtenir des liens vers la documentation et des explications supplémentaires

      1. Sélectionnez Calcul Spark serverless dans la liste déroulante Calcul de la barre de navigation supérieure. Cette opération peut prendre une ou deux minutes. Attendez qu’une barre d’état en haut affiche Configurer la session
      2. Sélectionnez Configurer la session dans la barre d’état en haut
      3. Sélectionnez Packages Python
      4. Sélectionnez Charger le fichier conda.
      5. Sélectionnez le fichier azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml qui se trouve sur votre appareil local.
      6. (Facultatif) Augmentez le délai d’expiration de la session (temps d’inactivité en minutes) pour réduire le temps de démarrage du cluster Spark serverless

  4. Cette cellule de code démarre la session Spark. Il faut environ 10 minutes pour installer toutes les dépendances et démarrer la session 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. Configurer le répertoire racine pour les exemples

    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. Configuration de l’interface CLI Azure Machine Learning :

    • Installer l’extension CLI Azure Machine Learning

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

    • Authentifier

      # authenticate
!az login

    • Définir l’abonnement par défaut

      # Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id

    Remarque

    Un espace de travail de magasin de fonctionnalités prend en charge la réutilisation des fonctionnalités entre les projets. Un espace de travail de projet (l’espace de travail actuel utilisé) tire parti des fonctionnalités d’un magasin de fonctionnalités spécifique pour la formation et l’inférence des modèles. De nombreux espaces de travail de projet peuvent partager et réutiliser le même espace de travail de magasin de caractéristiques.

Provisionner les ressources nécessaires

Vous pouvez créer un compte de stockage et des conteneurs Azure Data Lake Storage (ADLS) Gen2, ou réutiliser le compte de stockage et les ressources de conteneur existants pour le magasin de caractéristiques. Dans une situation réelle, différents comptes de stockage peuvent héberger les conteneurs ADLS Gen2. Les deux options fonctionnent et dépendent de vos besoins spécifiques.

Pour ce tutoriel, vous créez trois conteneurs de stockage distincts dans le même compte de stockage ADLS Gen2 :

  • Données sources
  • Stockage hors connexion
  • Données d’observation

  1. Créez un compte de stockage ADLS Gen2 pour les données sources, le magasin hors connexion et les données d’observation.

    1. Indiquez le nom d’un compte de stockage Azure Data Lake Storage Gen2 dans l’exemple de code suivant. Vous pouvez exécuter la cellule de code suivante avec les paramètres par défaut fournis. Vous pouvez éventuellement remplacer les paramètres par défaut.

      ## 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. Cette cellule de code crée le compte de stockage ADLS Gen2 défini dans la cellule de code ci-dessus.

      # 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. Cette cellule de code crée un conteneur de stockage pour le magasin hors connexion.

      # 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. Cette cellule de code crée un conteneur de stockage pour les données sources.

      # 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. Cette cellule de code crée un conteneur de stockage pour les données d’observation.

      # 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. Copiez les exemples de données nécessaires pour cette série de tutoriels dans les conteneurs de stockage nouvellement créés.

    1. Pour écrire des données dans les conteneurs de stockage, vérifiez que les rôles Contributeur et Contributeur aux données blob de stockage sont attribués à l’identité utilisateur sur le compte de stockage ADLS Gen2 créé dans le portail Azure en suivant ces étapes.

      Important

      Une fois que vous avez vérifié que les rôles Contributeur et Contributeur aux données blob de stockage sont attribués à l’identité utilisateur, attendez quelques minutes après l’attribution de rôle que les autorisations se propagent avant de passer aux étapes suivantes. Pour en savoir plus sur le contrôle d’accès, consultez Contrôle d’accès en fonction du rôle (RBAC) pour les comptes de stockage Azure

      Les cellules de code suivantes copient des exemples de données sources pour l’ensemble de caractéristiques de transactions utilisé dans ce tutoriel à partir d’un compte de stockage public vers le compte de stockage nouvellement créé.

      # 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. Pour l’ensemble de caractéristiques de compte utilisé dans ce tutoriel, copiez les exemples de données sources pour l’ensemble de caractéristiques du compte sur le compte de stockage nouvellement créé.

      # 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. Copiez les exemples de données d’observation utilisés pour la formation à partir d’un compte de stockage public vers le compte de stockage nouvellement créé.

      # 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. Copiez les exemples de données d’observation utilisés pour l’inférence par lots à partir d’un compte de stockage public vers le compte de stockage nouvellement créé.

      # 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. Désactivez l’accès au réseau public sur le compte de stockage nouvellement créé.

    1. Cette cellule de code désactive l’accès au réseau public pour le compte de stockage ADLS Gen2 créé précédemment.

      # 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. Définissez des ID ARM pour les conteneurs du magasin hors connexion, des données sources et des données d’observation.

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

Créer un magasin de caractéristiques avec la matérialisation activée

Définir les paramètres du magasin de caractéristiques

Définissez le nom du magasin de caractéristiques, l’emplacement, l’ID d’abonnement, le nom du groupe et les valeurs d’ID ARM, comme indiqué dans cet exemple de cellule de code :

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

La cellule de code suivante génère un fichier de spécification YAML pour un magasin de fonctionnalités avec la matérialisation activée.

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

Créer le magasin de fonctionnalités

Cette cellule de code crée un magasin de fonctionnalités avec la matérialisation activée en utilisant le fichier de spécification YAML généré à l’étape précédente.

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

Initialiser le client SDK de base du magasin de caractéristiques d’Azure Machine Learning

Le client SDK initialisé dans cette cellule facilite le développement et la consommation des caractéristiques :

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

Attribuer des rôles à l’identité de l’utilisateur sur le magasin de fonctionnalités

Suivez ces instructions pour obtenir l’ID d’objet Microsoft Entra de votre identité utilisateur. Ensuite, utilisez votre ID d’objet Microsoft Entra dans la commande suivante pour attribuer le rôle Scientifique des données AzureML à votre identité utilisateur sur le magasin de fonctionnalités créé.

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

Obtenir le compte de stockage et le coffre de clés par défaut pour le magasin de caractéristiques, et désactiver l’accès aux ressources correspondantes sur le réseau public

La cellule de code suivante retourne l’objet de magasin de fonctionnalités pour les étapes suivantes.

fs = featurestore.feature_stores.get()

Cette cellule de code retourne les noms du compte de stockage et du coffre de clés par défaut pour le magasin de fonctionnalités.

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

Cette cellule de code désactive l’accès au compte de stockage par défaut sur le réseau public pour le magasin de caractéristiques.

# 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 cellule suivante imprime le nom du coffre de clés par défaut pour le magasin de fonctionnalités.

print(default_key_vault_name)

Désactiver l’accès au réseau public pour le coffre de clés du magasin de caractéristiques par défaut créé précédemment

  • Ouvrez le coffre de clés par défaut que vous avez créé dans la cellule précédente, dans le Portail Microsoft Azure.
  • Sélectionnez l’onglet Réseau.
  • Sélectionnez Désactiver l’accès public, puis Appliquer en bas à gauche de la page.

Activer le réseau virtuel managé pour l’espace de travail du magasin de caractéristiques

Mettre à jour le magasin de caractéristiques avec les règles de trafic sortant nécessaires

La cellule de code suivante crée un fichier de spécification YAML pour les règles de trafic sortant définies pour le magasin de fonctionnalités.

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

Cette cellule de code utilise le fichier de spécification YAML généré pour mettre à jour le magasin de fonctionnalités.

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

Créer des points de terminaison privés pour les règles de trafic sortant définies

Une commande provision-network crée des points de terminaison privés à partir du réseau virtuel managé où le travail de matérialisation s’exécute sur la source, le magasin hors connexion, les données d’observation, le compte de stockage par défaut et le coffre de clés par défaut pour le magasin de fonctionnalités. Cette commande peut pendre environ 20 minutes.

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

Cette cellule de code confirme la création de points de terminaison privés définis par les règles de trafic sortant.

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

Mettre à jour le réseau virtuel managé pour l’espace de travail de projet

Ensuite, mettez à jour le réseau virtuel managé pour l’espace de travail de projet. Tout d’abord, obtenez l’ID d’abonnement, le groupe de ressources et le nom de l’espace de travail du projet.

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

Mettre à jour l’espace de travail de projet avec les règles de trafic sortant nécessaires

L’espace de travail de projet doit accéder à ces ressources :

  • Données sources
  • Stockage hors connexion
  • Données d’observation
  • Magasin de fonctionnalités
  • Compte de stockage par défaut du magasin de caractéristiques

Cette cellule de code met à jour l’espace de travail de projet en utilisant le fichier de spécification YAML généré avec les règles de trafic sortant nécessaires.

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

Cette cellule de code met à jour l’espace de travail de projet en utilisant le fichier de spécification YAML généré avec les règles de trafic sortant.

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

Cette cellule de code confirme la création de points de terminaison privés définis par les règles de trafic sortant.

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

Vous pouvez également vérifier les règles de trafic sortant à partir du Portail Microsoft Azure. Accédez à Réseautage depuis le panneau gauche de l'espace de travail du projet, puis ouvrez l'onglet Accès sortant géré au sein de l'espace de travail.

Cette capture d’écran montre les règles de trafic sortant d’un espace de travail de projet dans le portail Azure.

Prototyper et développer un ensemble de caractéristiques d’agrégation cumulative des transactions

Explorer les données sources des transactions

Remarque

Un conteneur de blobs accessible au public héberge les exemples de données utilisés dans ce tutoriel. Il peut être lu uniquement dans Spark avec un pilote wasbs. Quand vous créez des ensembles de caractéristiques en utilisant vos propres données sources, hébergez-les dans un compte ADLS Gen2 et utilisez un pilote abfss dans le chemin des données.

# 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

Développer localement un ensemble de caractéristiques de transactions

Une spécification d’ensemble de caractéristiques est une définition autonome d’un ensemble de caractéristiques qui peut être développée et testée localement.

Créez les caractéristiques d’agrégation de fenêtres dynamiques suivantes :

  • nombre de transactions sur trois jours
  • somme des montants des transactions sur trois jours
  • moyenne des montants des transactions sur trois jours
  • nombre de transactions sur sept jours
  • somme des montants des transactions sur sept jours
  • moyenne des montants des transactions sur sept jours

Inspectez le fichier de code de transformation des caractéristiques featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.py. Ce transformateur Spark effectue l’agrégation cumulative définie pour les caractéristiques.

Pour des informations plus détaillées sur l’ensemble de caractéristiques et les transformations, consultez les concepts du magasin de fonctionnalités.

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

Exporter une spécification d’ensemble de caractéristiques

Pour inscrire une spécification d’ensemble de caractéristiques dans le magasin de caractéristiques, vous devez enregistrer cette spécification dans un format spécifique.

Pour inspecter la spécification d’ensemble de caractéristiques de transactions générée, ouvrez ce fichier à partir de l’arborescence de fichiers pour voir la spécification :

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

La spécification contient les éléments suivants :

  • source : référence à une ressource de stockage. Dans ce cas, un fichier Parquet dans une ressource de stockage blob
  • features : une liste de caractéristiques et de leur type de données. Si vous fournissez un code de transformation
  • index_columns : les clés de jointure nécessaires pour accéder aux valeurs à partir de l’ensemble de caractéristiques

L’avantage également de conserver une spécification d’ensemble de caractéristiques sous forme de fichier YAML est que la spécification peut bénéficier de la gestion de version. En savoir plus sur la spécification d’ensemble de caractéristiques dans le document des entités du magasin de caractéristiques de niveau supérieur et les informations de référence sur la spécification YAML des ensembles de caractéristiques.

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)

Inscrire une entité de magasin de fonctionnalités

Les entités aident à imposer l’utilisation des mêmes définitions de clé de jointure entre les ensembles de caractéristiques qui utilisent les mêmes entités logiques. Les comptes, les clients, etc. sont des exemples d’entités. Les entités sont généralement créées une seule fois, puis réutilisées entre les ensembles de caractéristiques. Pour plus d’informations, consultez le document sur les entités de magasin de fonctionnalités de niveau supérieur.

Cette cellule de code crée une entité de compte pour le magasin de caractéristiques.

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

Inscrire l’ensemble de caractéristiques de transactions dans le magasin de caractéristiques et envoyer un travail de matérialisation

Pour partager et réutiliser une ressource d’ensemble de caractéristiques, vous devez d’abord inscrire cette ressource dans le magasin de caractéristiques. L’inscription de ressources d’ensemble de caractéristiques offre des fonctionnalités managées, notamment le versioning et la matérialisation. Cette série de tutoriels traite de ces sujets.

La ressource de l’ensemble de caractéristiques référence à la fois la spécification d’ensemble de caractéristiques que vous avez créée précédemment, et d’autres propriétés, par exemple les paramètres de version et de matérialisation.

Créer un ensemble de caractéristiques

La cellule de code suivante utilise un fichier de spécification YAML prédéfini pour créer un ensemble de fonctionnalités.

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

Cette cellule de code affiche un aperçu de l’ensemble de caractéristiques nouvellement créé.

# 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

Envoyer un travail de matérialisation de renvoi

La cellule de code suivante définit les valeurs de temps de début et de fin de la fenêtre de matérialisation des caractéristiques, et envoie un travail de matérialisation de renvoi.

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

Cette cellule de code fournit <JOB_ID_FROM_PREVIOUS_COMMAND>, pour vérifier l’état du travail de matérialisation de renvoi.

### Check the job status

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

Cette cellule de code liste tous les travaux de matérialisation pour l’ensemble de caractéristiques actuel.

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

Attacher Azure Cache pour Redis en tant que magasin en ligne

Créer un cache Azure pour Redis

Dans la cellule de code suivante, définissez le nom de l’Azure Cache pour Redis que vous souhaitez créer ou réutiliser. Vous pouvez éventuellement remplacer d’autres paramètres par défaut.

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

Vous pouvez sélectionner le niveau de cache Redis (de base, standard ou Premium). Vous devez choisir une famille de références SKU disponible pour le niveau de cache sélectionné. Consultez cette ressource de documentation pour plus d’informations sur la façon dont la sélection de différents niveaux peut avoir un impact sur les performances du cache. Consultez cette ressource de documentation pour obtenir plus d’informations sur la tarification des différents niveaux de référence SKU et de familles d’Azure Cache pour Redis.

Exécutez la cellule de code suivante pour créer une instance Azure Cache pour Redis avec le niveau Premium, la famille de SKU P et la capacité de cache 2. L’approvisionnement de l’instance Redis peut prendre environ 5 à 10 minutes.

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

Mettre à jour le magasin de fonctionnalités avec le magasin en ligne

Attachez l’Azure Cache pour Redis au magasin de fonctionnalités pour l’utiliser comme magasin de matérialisation en ligne. La cellule de code suivante crée un fichier de spécification YAML avec des règles de trafic sortant de magasin en ligne, définies pour le magasin de fonctionnalités.

# 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 cellule de code suivante met à jour le magasin de fonctionnalités avec le fichier de spécification YAML généré avec les règles de trafic sortant pour le magasin en ligne.

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

Mettre à jour les règles de trafic sortant de l’espace de travail du projet

L’espace de travail du projet doit accéder au magasin en ligne. La cellule de code suivante crée un fichier de spécification YAML avec les règles de trafic sortant requises pour l’espace de travail du projet.

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)

Exécutez la cellule de code suivante pour mettre à jour l’espace de travail du projet avec le fichier de spécification YAML généré avec les règles de trafic sortant pour le magasin en ligne.

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

Matérialiser l’ensemble de caractéristiques de transactions défini sur le magasin en ligne

La cellule de code suivante active la matérialisation en ligne pour l’ensemble de caractéristiques 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 cellule de code suivante définit les heures de début et de fin de la fenêtre de matérialisation des caractéristiques et envoie un travail de matérialisation de renvoi.

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

Utiliser les caractéristiques inscrites pour générer des données d’entraînement

Charger les données d’observation

Tout d’abord, explorez les données d’observation. Les données de base utilisées pour l’entraînement et l’inférence comprennent généralement des données d’observation. Ces données sont ensuite jointes à des données de caractéristiques pour créer une ressource de données de formation complète. Les données d’observation sont les données capturées pendant la durée de l’événement. Dans ce cas, les données de transactions de base comprennent l’ID de transaction, l’ID de compte et les valeurs du montant de transaction. Ici, comme les données d’observation sont utilisées pour l’entraînement, la variable cible est également ajoutée (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

Obtenir l’ensemble de fonctionnalités inscrit et répertorier ses fonctionnalités

Ensuite, obtenez un ensemble de caractéristiques en fournissant son nom et sa version, puis listez les caractéristiques de cet ensemble de caractéristiques. Imprimez également des exemples de valeurs de caractéristique.

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

Sélectionner des fonctionnalités et générer des données d’entraînement

Sélectionnez les caractéristiques pour les données d’entraînement, et utilisez le SDK du magasin de caractéristiques pour générer les données d’entraînement.

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

Une jointure à un point dans le temps a ajouté les caractéristiques aux données de formation.

Étapes suivantes facultatives

Maintenant que vous avez créé un magasin de fonctionnalités sécurisé et envoyé une exécution de matérialisation réussie, vous pouvez suivre la série de tutoriels pour mieux comprendre le magasin de fonctionnalités.

Ce tutoriel regroupe des étapes des tutoriels 1 et 2 de cette série. N’oubliez pas de remplacer les conteneurs de stockage public nécessaires utilisés dans les autres notebooks du tutoriel par ceux créés dans le notebook de ce tutoriel, pour l’isolement réseau.

Cela conclut ce didacticiel. Vos données d’entraînement utilisent les caractéristiques d’un magasin de caractéristiques. Vous pouvez les enregistrer dans le stockage pour les utiliser par la suite ou exécuter directement l’entraînement du modèle sur ces données.

Étapes suivantes

  • Last updated on