Tutorial 6: Aislamiento de red con el almacén de características

Artículo
09/04/2024

El almacén de características gestionado de Azure Machine Learning le permite detectar, crear y operacionalizar características. Las características sirven como tejido conectivo en el ciclo de vida del aprendizaje automático, empezando por la fase de creación de prototipos, donde experimenta con diversas características. Ese ciclo de vida continúa con la fase de operacionalización, donde se implementan los modelos y los pasos de inferencia buscan los datos de características. Para obtener más información sobre los almacenes de características, lea el documento de conceptos del almacén de características.

En este tutorial se describe cómo configurar la entrada segura a través de un punto de conexión privado y la salida segura a través de una red virtual administrada.

La parte 1 de esta serie de tutoriales mostró cómo crear una especificación de conjunto de características con transformaciones personalizadas, y usar ese conjunto de características para generar datos de entrenamiento. En la parte 2 de la serie se ha mostrado cómo habilitar la materialización y realizar un reposición. Además, en la parte 2 se ha mostrado cómo experimentar con características como una manera de mejorar el rendimiento del modelo. En la parte 3 se ha mostrado cómo un almacén de características aumenta la agilidad en los flujos de experimentación y entrenamiento. En la parte 3 también se ha descrito cómo ejecutar la inferencia por lotes. En el Tutorial 4 se explicó cómo usar el almacén de características para casos de uso de inferencia en línea o en tiempo real. En el tutorial 5 se mostró cómo desarrollar un conjunto de características con un origen de datos personalizado. Tutorial 6 muestra cómo

Configure los recursos necesarios para el aislamiento de red de un almacén de características gestionado.
Creación de un nuevo recurso de almacén de características.
Configure el almacén de características para admitir escenarios de aislamiento de red.
Actualice el área de trabajo del proyecto (área de trabajo actual) para admitir escenarios de aislamiento de red.

Requisitos previos

Nota:

Este tutorial utiliza un cuaderno de Azure Machine Learning con Serverless Spark Compute.

Un área de trabajo de Azure Machine Learning habilitada con una red virtual administrada para trabajos spark sin servidor.
Para configurar el área de trabajo del proyecto:
1. Cree un archivo YAML denominado network.yml:
```
managed_network:
isolation_mode: allow_internet_outbound
```
2. Ejecute estos comandos para actualizar el área de trabajo y aprovisionar la red virtual administrada para trabajos de Spark sin servidor:
```
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
```
Para obtener más información, visite Configuración de trabajos de spark sin servidor.
La cuenta de usuario debe tener asignado el rol Ownero Contributor al grupo de recursos donde se crea el almacén de características. La cuenta de usuario también necesita el User Access Administrator rol.

Importante

Para su área de trabajo de Azure Machine Learning, establezca el isolation_mode a allow_internet_outbound. Este es el único modo de aislamiento de red admitido. En este tutorial se muestra cómo conectarse a orígenes, almacenamiento de materialización y datos de observación de forma segura a través de puntos de conexión privados.

Configurar

En este tutorial se usa el SDK principal del almacén de características de Python (azureml-featurestore). El SDK de Python solo se usa para el desarrollo y las pruebas del conjunto de características. La CLI se usa para las operaciones de creación, lectura, actualización y eliminación (CRUD), en almacenes de características, conjuntos de características y entidades de almacén de características. Esto es útil en escenarios de integración continua y entrega continua (CI/CD) o GitOps donde se prefiere CLI/YAML.

No es necesario instalar explícitamente estos recursos para este tutorial, ya que en las instrucciones de configuración que se muestran aquí, el conda.yaml archivo los cubre.

Preparación del entorno de cuadernos para el desarrollo:

Clone el repositorio azureml-examples en los recursos locales de GitHub con este comando:

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

También puede descargar un archivo zip del repositorio azureml-examples. En esta página, seleccione primero la lista desplegable code y, a continuación, seleccione Download ZIP. A continuación, descomprima el contenido en una carpeta del dispositivo local.
Cargue el directorio de muestras del almacén de características en el área de trabajo del proyecto
1. En el área de trabajo de Azure Machine Learning, abra la interfaz de usuario de Estudio de Azure Machine Learning.
2. Seleccione Notebooks en el panel de navegación izquierdo.
3. Seleccione el nombre de usuario en la lista de directorios.
4. Seleccione los puntos suspensivos (...) y, a continuación, seleccione Cargar carpeta.
5. Seleccione la carpeta de ejemplos del almacén de características en la ruta de acceso del directorio clonado: azureml-examples/sdk/python/featurestore-sample
Ejecución del tutorial
- Opción 1: Cree un nuevo cuaderno y ejecute las instrucciones de este documento, paso a paso.
- Opción 2: Abra el cuaderno featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynbexistente. Puede mantener abierto este documento y consultarlo para obtener más explicaciones y enlaces a la documentación.
  1. Seleccione Serverless Spark Compute en el menú desplegable Compute de la navegación superior. Esta operación podría tardar uno o dos minutos. Espere a que la barra de estado de la parte superior muestre la opción Configurar sesión.
  2. Seleccione Configurar sesión en la barra de navegación superior.
  3. Seleccione paquetes de Python.
  4. Seleccione Cargar archivo de Conda.
  5. Seleccione el archivo azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml ubicado en el dispositivo local.
  6. (Opcional) Aumente el tiempo de espera de la sesión (tiempo de inactividad en minutos) para reducir el tiempo de arranque del clúster spark sin servidor.

Esta celda de código inicia la sesión de Spark. Necesita unos 10 minutos para instalar todas las dependencias e iniciar la sesión de 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")

Configuración del directorio raíz para los ejemplos

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

Configure la CLI de Azure Machine Learning:
- Instale la extensión CLI de Azure Machine Learning
```
# install azure ml cli extension
!az extension add --name ml
```
- Authenticate
```
# authenticate
!az login
```
- Establezca la suscripción predeterminada
```
# Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```
Nota:

Un área de trabajo del almacén de características admite la reutilización de características entre proyectos. Un área de trabajo del proyecto ( el área de trabajo actual en uso) aprovecha las características de un almacén de características específico para entrenar e inferencia los modelos. Muchas áreas de trabajo del proyecto pueden compartir y reutilizar el mismo área de trabajo del almacén de características.

Aprovisionamiento de los recursos necesarios

Puede crear una cuenta de almacenamiento y contenedores de Azure Data Lake Storage (ADLS) Gen2, o reutilizar la cuenta de almacenamiento y los recursos de contenedor existentes para el almacén de características. En una situación real, las distintas cuentas de almacenamiento pueden hospedar los contenedores de ADLS Gen2. Ambas opciones funcionan en función de sus requisitos específicos.

En este tutorial, creará tres contenedores de almacenamiento independientes en la misma cuenta de almacenamiento de ADLS Gen2:

Datos de origen
Tienda sin conexión
Datos de observación

Cree una cuenta de almacenamiento de ADLS Gen2 para los datos de origen, el almacén sin conexión y los datos de observación.

Proporcione el nombre de una cuenta de almacenamiento Azure Data Lake Storage Gen2 en el ejemplo de código siguiente. Puede ejecutar la siguiente celda de código con la configuración predeterminada proporcionada. Opcionalmente, puede invalidar la configuración predeterminada.

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

Esta celda de código crea la cuenta de almacenamiento de ADLS Gen2 definida en la celda de código anterior.

# 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

Esta celda de código crea un nuevo contenedor de almacenamiento para el almacén sin conexión.

# 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

Esta celda de código crea un nuevo contenedor de almacenamiento para los datos de origen.

# 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

Esta celda de código crea un nuevo contenedor de almacenamiento para los datos de observación.

# 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

Copie los datos de ejemplo necesarios para esta serie de tutoriales en los contenedores de almacenamiento recién creados.

Para escribir datos en los contenedores de almacenamiento, asegúrese de que los roles Colaborador y Colaborador de datos de blobs de almacenamiento estén asignados a la identidad de usuario en la cuenta de almacenamiento de ADLS Gen2 creada en el Azure Portal siguiendo estos pasos.

Importante

Una vez se asegure de que los roles Colaborador y Colaborador de datos de blobs de almacenamiento se asignan a la identidad del usuario, espere unos minutos después de la asignación de roles para permitir que los permisos se propaguen antes de continuar con los pasos siguientes. Para más información sobre el control de acceso, visite Control de acceso basado en roles (RBAC) para cuentas de almacenamiento de Azure

Las celdas de código siguientes copian datos de origen de ejemplo para el conjunto de características de transacciones que se usan en este tutorial desde una cuenta de almacenamiento pública a la cuenta de almacenamiento recién creada.
```
# 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/"
)
```

Para el conjunto de características de la cuenta usado en este tutorial, copie los datos de origen de ejemplo para el conjunto de características de la cuenta en la cuenta de almacenamiento recién creada.

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

Copie los datos de observación de ejemplo usados para el entrenamiento de una cuenta de almacenamiento pública en la cuenta de almacenamiento recién creada.

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

Copie los datos de observación de ejemplo usados para la inferencia por lotes de una cuenta de almacenamiento pública a la cuenta de almacenamiento recién creada.

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

Deshabilite el acceso a la red pública en la cuenta de almacenamiento recién creada.

Esta celda de código deshabilita el acceso a la red pública para la cuenta de almacenamiento de ADLS Gen2 creada anteriormente.

# 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

Establezca los identificadores de ARM para el almacén sin conexión, los datos de origen y los contenedores de datos de observación.

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

Creación de un almacén de características con materialización habilitada

Establecimiento de los parámetros del almacén de características

Establezca los valores del nombre, la ubicación, el id. de suscripción, el nombre del grupo y el id. de ARM, como se muestra en este ejemplo de celda de código:

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

Esta celda de código genera un archivo de especificación YAML para un almacén de características con materialización habilitada.

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

Creación del almacén de características

Esta celda de código usa el archivo de especificación YAML generado en el paso anterior para crear un almacén de características con materialización habilitada.

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

Inicializar el cliente del SDK principal del almacén de características de Azure Machine Learning

El cliente del SDK inicializado en esta celda facilita el desarrollo y el consumo de características:

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

Asignación de roles a la identidad de usuario en el almacén de características

Siga estas instrucciones para obtener el identificador de objeto de Microsoft Entra para la identidad del usuario. A continuación, use el Id. de objeto de Microsoft Entra en el siguiente comando para asignar el rol Científico de datos de AzureML a la identidad de usuario en el almacén de características creado.

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

Obtenga la cuenta de almacenamiento predeterminada y el almacén de claves para el almacén de características y deshabilite el acceso de red pública a los recursos correspondientes.

La celda de código siguiente devuelve el objeto de almacén de características para los pasos siguientes.

fs = featurestore.feature_stores.get()

Esta celda de código devuelve los nombres de la cuenta de almacenamiento predeterminada y el almacén de claves para el almacén de características.

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

Esta celda de código deshabilita el acceso de red pública a la cuenta de almacenamiento predeterminada para el almacén de características.

# 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

En la celda siguiente se imprime el nombre del almacén de claves predeterminado para el almacén de características.

print(default_key_vault_name)

Deshabilitación del acceso a la red pública para el almacén de características predeterminado creado anteriormente

En el Azure Portal, abra el almacén de claves predeterminado que creó en la celda anterior.
Seleccione la pestaña Redes.
Seleccione Deshabilitar acceso público y, a continuación, seleccione Aplicar en la parte inferior izquierda de la página.

Habilitación de la red virtual administrada para el área de trabajo del almacén de características

Actualización del almacén de características con las reglas de salida necesarias

La celda de código siguiente crea un archivo de especificación YAML para las reglas de salida definidas para el almacén de características.

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

Esta celda de código usa el archivo de especificación YAML generado para actualizar el almacén de características.

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

Creación de puntos de conexión privados para las reglas de salida definidas

Un comando provision-network crea puntos de conexión privados desde la red virtual administrada donde se ejecuta el trabajo de materialización en el origen, el almacén sin conexión, los datos de observación, la cuenta de almacenamiento predeterminada y el almacén de claves predeterminado para el almacén de características. Este comando podría necesitar aproximadamente 20 minutos para completarse.

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

Esta celda de código confirma la creación de puntos de conexión privados definidos por las reglas de salida.

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

Actualización de la red virtual administrada para el área de trabajo del proyecto

A continuación, actualice la red virtual administrada para el área de trabajo del proyecto. En primer lugar, obtenga el id. de suscripción, el grupo de recursos y el nombre del área de trabajo del proyecto.

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

Actualización del área de trabajo del proyecto con las reglas de salida necesarias

El área de trabajo del proyecto necesita acceso a estos recursos:

Datos de origen
Tienda sin conexión
Datos de observación
Almacén de características
Cuenta de almacenamiento predeterminada del almacén de características

Esta celda de código actualiza el área de trabajo del proyecto mediante el archivo de especificación YAML generado con las reglas de salida necesarias.

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

Esta celda de código actualiza el área de trabajo del proyecto mediante el archivo de especificación YAML generado con las reglas de salida.

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

Esta celda de código confirma la creación de puntos de conexión privados definidos por las reglas de salida.

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

También puede comprobar las reglas de salida desde Azure Portal. Vaya a Redes desde el panel de navegación izquierdo del área de trabajo del proyecto y, a continuación, abra la pestaña Acceso de salida administrado del área de trabajo.

Prototipo y desarrollo de un conjunto de características de agregación gradual de transacciones

Exploración de los datos de origen de transacciones

Nota:

Un contenedor de blobs accesible públicamente hospeda los datos de ejemplo usados en este tutorial. Solo se puede leer en Spark mediante elwasbs controlador. Al crear conjuntos de características con sus propios datos de origen, hospédelos en una cuenta de ADLS Gen2 y use un controlador abfss en la ruta de acceso de datos.

# 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

Desarrollo local de un conjunto de características de transacciones

Una especificación del conjunto de características es una definición independiente del conjunto de características que se puede desarrollar y probar localmente.

Cree las siguientes características de agregado de ventana gradual:

recuento de transacciones de tres días
suma de las cantidades de las transacciones de tres días
media de las cantidades de las transacciones de tres días
recuento de transacciones de siete días
suma de las cantidades de las transacciones de siete días
media de las cantidades de las transacciones de siete días

Inspeccione el archivo del código de transformación de características: featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.py. Este transformador de spark realiza la agregación gradual definida para las características.

Para obtener más información sobre el conjunto de características y las transformaciones con más detalle, visite conceptos del almacén de características.

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

Exportar una especificación de conjunto de características

Para registrar la especificación de conjunto de características con el almacén de características, se debe guardar la especificación en un formato específico.

Para inspeccionar la especificación del conjunto de características de transacciones generadas, abra este archivo desde el árbol de archivos para ver la especificación:

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

La especificación contiene estos elementos:

source: una referencia a un recurso de almacenamiento: en este caso, un archivo parquet en un recurso de almacenamiento de blobs
features: una lista de características y sus tipos de datos. Si proporciona código de transformación
index_columns: claves de combinación necesarias para acceder a los valores del conjunto de características

Como otra ventaja de conservar una especificación del conjunto de características como un archivo YAML, la especificación puede controlar la versión. Obtenga más información sobre la especificación del conjunto de características en el documento de entidades del almacén de características de nivel superior y en la referencia YAML de especificación del conjunto de características.

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)

Registro de la entidad del almacén de características

Las entidades ayudan a aplicar el uso de la misma definición de clave de combinación entre conjuntos de características que usan las mismas entidades lógicas. Entre los ejemplos de entidades se pueden incluir entidades de cuenta, entidades de cliente, etc. Normalmente, las entidades se crean una vez y, a continuación, se reutilizan en conjuntos de características. Para obtener más información, visite el documento de entidades del almacén de características de nivel superior.

Esta celda de código crea una entidad de cuenta para el almacén de características.

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

Registrar el conjunto de características de transacción con el almacén de características y enviar un trabajo de materialización

Para compartir y reutilizar un recurso de conjunto de características, primero debe registrar ese recurso en el almacén de características. El registro de recursos del conjunto de características ofrece funcionalidades administradas, incluido el control de versiones y la materialización. En esta serie de tutoriales se tratan estos temas.

El recurso del conjunto de características hace referencia a la especificación del conjunto de características que creó anteriormente y a otras propiedades; por ejemplo, la configuración de versión y materialización.

Creación de un conjunto de características

La celda de código siguiente usa un archivo de especificación YAML predefinido para crear un conjunto de características.

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

Esta celda de código previsualiza el conjunto de características recién creado.

# 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

Envío de un trabajo de materialización de reposición

En la celda de código siguiente se definen los valores de hora de inicio y finalización de la ventana de materialización de características y se envía un trabajo de materialización de reposición.

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

Esta celda de código proporciona <JOB_ID_FROM_PREVIOUS_COMMAND> para comprobar el estado del trabajo de materialización de reposición.

### Check the job status

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

Esta celda de código enumera todos los trabajos de materialización del conjunto de características actual.

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

Adjuntar Azure Cache for Redis como tienda en línea

Creación de una instancia de Azure Redis Cache

En la celda de código siguiente, defina el nombre de la instancia de Azure Cache for Redis que desea crear o reutilizar. Opcionalmente, puede invalidar la configuración predeterminada.

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

Puede seleccionar el nivel de caché de Redis (básico, estándar o premium). Debe elegir una familia de SKU que esté disponible para el nivel de caché seleccionado. Visite este recurso de documentación para obtener más información sobre cómo la selección de diferentes niveles puede afectar al rendimiento de la caché. Visite este recurso de documentación para más información sobre los precios de diferentes niveles de SKU y familias de Azure Cache for Redis.

Ejecute la siguiente celda de código para crear una instancia de Azure Cache for Redis con nivel premium, familia de SKU P y capacidad de caché 2. Puede tardar aproximadamente entre 5 y 10 minutos en aprovisionar la instancia de Redis.

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

Actualizar el almacén de características con la tienda en línea

Adjunte la instancia de Azure Cache for Redis al almacén de características para usarlo como almacén de materialización en línea. La celda de código siguiente crea un archivo de especificación de YAML con reglas de salida del almacén en línea definidas para el almacén de características.

# 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 siguiente celda de código actualiza el almacén de características con el archivo de especificación YAML generado con las reglas de salida para la tienda en línea.

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

Actualización de reglas de salida del área de trabajo del proyecto

El área de trabajo del proyecto necesita acceso a la tienda en línea. La celda de código siguiente crea un archivo de especificación YAML con las reglas de salida necesarias para el área de trabajo del proyecto.

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)

Ejecute la siguiente celda de código para actualizar el área de trabajo del proyecto con el archivo de especificación YAML generado con las reglas de salida para el almacén en línea.

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

Materialización del conjunto de características de transacciones en la tienda en línea

La celda de código siguiente habilita la materialización en línea del conjunto de características 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 celda de código siguiente define las horas de inicio y finalización de la ventana de materialización de características y envía un trabajo de materialización de reposición.

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

Uso de las características registradas para generar datos de entrenamiento

Carga de los datos de observación

En primer lugar, exploramos los datos de observación. Los datos principales utilizados para el entrenamiento y la inferencia suelen implicar datos de observación. A continuación, esos datos se unen a los datos de características para crear un recurso de datos de entrenamiento completo. Los datos de observación son los datos capturados en el momento del evento. En este caso, tiene los datos básicos de la transacción, incluidos el Id. de la transacción, el Id. de la cuenta y los valores del importe de la transacción. Aquí, dado que los datos de observación se usan para el entrenamiento, también tiene la variable de destino anexada (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

Obtención del conjunto de características registrado y enumeración de sus características

A continuación, obtenga un conjunto de características proporcionando su nombre y versión y, a continuación, enumere las características de este conjunto de características. Además, imprima algunos valores de características de ejemplo.

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

Selección de las características y generación de los datos de entrenamiento

Seleccione características para los datos de entrenamiento y use el SDK de almacén de características para generar los datos de entrenamiento.

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

Una combinación a un momento dado anexó las características a los datos de entrenamiento.

Pasos siguientes opcionales

Ahora que ha creado correctamente un almacén de características seguro y ha enviado una ejecución correcta de materialización, puede pasar por la serie de tutoriales para comprender el almacén de características.

Este tutorial contiene una combinación de pasos de los tutoriales 1 y 2 de esta serie. Recuerde reemplazar los contenedores de almacenamiento público necesarios que se usan en los otros cuadernos del tutorial por los creados en este cuaderno del tutorial para el aislamiento de red.

Así concluye el tutorial. Los datos de entrenamiento usan características de un almacén de características. Puede guardarlos en el almacenamiento para su uso posterior o puede ejecutar el entrenamiento del modelo directamente en ellos.

Compartir a través de