Partager via

Tutoriel 3 : activer la matérialisation récurrente et exécuter l’inférence par lots

Cette série de tutoriels montre comment les caractéristiques intègrent, de manière fluide, toutes les phases du cycle de vie Machine Learning : prototypage, apprentissage et opérationnalisation.

Le premier tutoriel a montré comment créer une spécification d’ensemble de fonctionnalités avec des transformations personnalisées. Ensuite, il a montré comment utiliser cet ensemble de fonctionnalités pour générer des données d’entraînement, activer la matérialisation et effectuer un renvoi. Le deuxième tutoriel a montré comment activer la matérialisation et effectuer un renvoi. Il a également montré comment expérimenter des fonctionnalités, comme un moyen d’améliorer les performances du modèle.

Ce didacticiel explique comment :

  • Activez la matérialisation récurrente pour l’ensemble de fonctionnalités transactions.
  • Exécutez un pipeline d’inférence par lots sur le modèle inscrit.

Prérequis

Avant de poursuivre ce tutoriel, veillez à suivre les premier et deuxième didacticiels de la série.

Configurer

  1. Configurez le notebook Spark Azure Machine Learning.

    Pour exécuter ce tutoriel, vous pouvez créer un notebook et suivre les instructions étape par étape. Vous pouvez également ouvrir et exécuter le notebook existant nommé 3. Activez la matérialisation récurrente et exécuter l’inférence par lots. Vous trouverez ce notebook, ainsi que tous les notebooks de cette série, dans le répertoire featurestore_sample/notebooks. Vous pouvez choisir sdk_only ou sdk_and_cli. Laissez ce tutoriel ouvert pour y trouver les références des liens de documentation et des explications supplémentaires.

    1. Dans la liste déroulante Calcul dans la partie supérieure de la navigation, sélectionnez Calcul Spark serverless sous Azure Machine Learning Serverless Spark.

    2. Configurer la session :

      1. Sélectionnez Configurer la session dans la barre d’état en haut.
      2. Sélectionnez l’onglet packages Python.
      3. Sélectionnez Charger le fichier conda.
      4. Sélectionnez le fichier azureml-examples/sdk/python/featurestore-sample/project/env/online.yml de votre ordinateur local.
      5. Vous pouvez également augmenter le délai d’expiration de session (temps d’inactivité) pour éviter d’avoir à réexécuter fréquemment les opérations prérequises.

  2. Démarrez 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")

  3. Configurez le répertoire racine des exemples.

    import os

# please update the dir to ./Users/<your_user_alias> (or any custom directory you uploaded the samples to).
# You can find the name from the directory structure in the left nav
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")

  4. Configurez l’interface CLI.

    Non applicable.

  1. Initialisez le client CRUD (créer, lire, mettre à jour et supprimer) de l’espace de travail du projet.

    Le notebook du tutoriel s’exécute à partir de cet espace de travail actuel.

    ### Initialize the MLClient of this project workspace
import os
from azure.ai.ml import MLClient
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

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

# connect to the project workspace
ws_client = MLClient(
    AzureMLOnBehalfOfCredential(), project_ws_sub_id, project_ws_rg, project_ws_name
)

  2. Initialisez les variables du magasin de fonctionnalités.

    Pour refléter ce que vous avez créé dans le premier tutoriel, veillez à mettre à jour la valeur featurestore_name.

    from azure.ai.ml import MLClient
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

# feature store
featurestore_name = (
    "<FEATURESTORE_NAME>"  # use the same name from part #1 of the tutorial
)
featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

# feature store ml client
fs_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    featurestore_subscription_id,
    featurestore_resource_group_name,
    featurestore_name,
)

  3. Initialisez le client SDK du magasin de fonctionnalités.

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

Activer la matérialisation récurrente sur l’ensemble de fonctionnalités de transactions

Dans le deuxième tutoriel, vous avez activé la matérialisation et effectué le renvoi sur l’ensemble de fonctionnalités transactions. Le renvoi est une opération ponctuelle à la demande qui calcule et place des valeurs de fonctionnalités dans le magasin de matérialisation.

Pour gérer l’inférence du modèle en production, vous pouvez configurer des tâches de matérialisation récurrentes pour tenir le magasin de matérialisation à jour. Ces tâches s’exécutent selon des planifications définies par l’utilisateur. La planification des tâches récurrentes fonctionne de cette façon :

  • Les valeurs d’intervalle et de fréquence définissent une fenêtre. Par exemple, les valeurs suivantes définissent une fenêtre de trois heures :

    • interval = 3
    • frequency = Hour

  • La première fenêtre démarre à la valeur start_time définie dans RecurrenceTrigger, ainsi de suite.

  • La première tâche récurrente est envoyée au début de la fenêtre suivante postérieure à l’heure de mise à jour.

  • Les tâches récurrentes ultérieures sont envoyées à chaque fenêtre après la première tâche.

Comme expliqué dans les tutoriels précédents, après avoir matérialisé les données (renvoi ou matérialisation récurrente), la récupération des fonctionnalités utilise les données matérialisées par défaut.

from datetime import datetime
from azure.ai.ml.entities import RecurrenceTrigger

transactions_fset_config = fs_client.feature_sets.get(name="transactions", version="1")

# create a schedule that runs the materialization job every 3 hours
transactions_fset_config.materialization_settings.schedule = RecurrenceTrigger(
    interval=3, frequency="Hour", start_time=datetime(2023, 4, 15, 0, 4, 10, 0)
)

fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)

print(fs_poller.result())

(Facultatif) Enregistrer le fichier YAML de ressource de l’ensemble de fonctionnalités

Nous utilisons les paramètres mis à jour pour enregistrer le fichier YAML.

## uncomment and run
# transactions_fset_config.dump(root_dir + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled_with_schedule.yaml")

Exécuter le pipeline d’inférence par lots

L’inférence par lots comprend les étapes suivantes :

  1. Vous utilisez le même composant de récupération de fonctionnalités intégré que celui utilisé dans le pipeline d’apprentissage, dont il est question dans le troisième tutoriel. Pour l’apprentissage du pipeline, vous avez fourni une spécification de récupération des fonctionnalités en tant qu’entrée de composant. Pour l’inférence par lots, vous passez le modèle inscrit comme entrée. Le composant recherche la spécification de récupération des fonctionnalités dans l’artefact du modèle.

    En outre, pour la formation, les données d’observation disposaient de la variable cible. Cependant, les données d’observation de l’inférence par lots ne comportent pas la variable cible. L’étape de récupération des fonctionnalités joint les données d’observation aux fonctionnalités et génère les données pour l’inférence par lots.

  2. Le pipeline utilise les données d’entrée d’inférence par lots de l’étape précédente, exécute l’inférence sur le modèle et ajoute la valeur prédite en tant que sortie.

    Remarque

    Vous utilisez une tâche pour l’inférence par lots dans cet exemple. Vous pouvez également utiliser des points de terminaison de lot dans Azure Machine Learning.

    from azure.ai.ml import load_job  # will be used later

# set the batch inference  pipeline path
batch_inference_pipeline_path = (
    root_dir + "/project/fraud_model/pipelines/batch_inference_pipeline.yaml"
)
batch_inference_pipeline_definition = load_job(source=batch_inference_pipeline_path)

# run the training pipeline
batch_inference_pipeline_job = ws_client.jobs.create_or_update(
    batch_inference_pipeline_definition
)

# stream the run logs
ws_client.jobs.stream(batch_inference_pipeline_job.name)

Inspecter les données de sortie d’inférence par lots

Dans la vue du pipeline :

  1. Sélectionnez inference_step dans la carte outputs.

  2. Copiez la valeur du champ Data. Il doit ressembler à ceci : azureml_995abbc2-3171-461e-8214-c3c5d17ede83_output_data_data_with_prediction:1.

  3. Collez la valeur du champ Data dans la cellule suivante, en séparant les valeurs de nom et de version. Le dernier caractère est la version, précédé d’un signe deux-points (:).

  4. Remarquez la colonne predict_is_fraud que le pipeline d’inférence par lots a générée.

    Dans les sorties du pipeline d’inférence par lots (/project/fraud_mode/pipelines/batch_inference_pipeline.yaml), le système a créé une ressource de données non suivie avec un GUID comme valeur de nom et 1 comme valeur de version. Cela s’est produit parce que vous n’avez pas fourni les valeurs name ou version pour outputs de inference_step. Dans cette cellule, vous dérivez puis affichez le chemin des données de la ressource.

    inf_data_output = ws_client.data.get(
    name="azureml_1c106662-aa5e-4354-b5f9-57c1b0fdb3a7_output_data_data_with_prediction",
    version="1",
)
inf_output_df = spark.read.parquet(inf_data_output.path + "data/*.parquet")
display(inf_output_df.head(5))

Nettoyage

Le cinquième tutoriel de la série décrit comment supprimer les ressources.

Étapes suivantes

  • Last updated on