Tutoriel n° 2 : expérimenter et entraîner des modèles en utilisant des caractéristiques

Article
09/30/2024

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 remplissage. Ce tutoriel montre comment activer la matérialisation et effectuer un renvoi. Il montre également l’expérience des caractéristiques, en tant que moyen d’améliorer les performances des modèles.

Dans ce tutoriel, vous allez apprendre à :

Prototyper une nouvelle spécification d’ensemble de caractéristiques accounts en utilisant des valeurs précalculées existantes en tant que caractéristiques. Vous inscrirez ensuite la spécification d’ensemble de caractéristiques locale en tant qu’ensemble de caractéristiques dans le magasin de caractéristiques. Ce processus de distingue du premier tutoriel dans lequel vous avez créé un ensemble de caractéristiques qui présentait des transformations personnalisées.
Sélectionner des caractéristiques pour le modèle à partir des ensembles de caractéristiques transactions et accounts, puis les enregistrer en tant que spécification de récupération de caractéristiques.
Exécuter un pipeline d’entraînement qui utilise la spécification de récupération de caractéristiques pour entraîner un nouveau modèle. Ce pipeline utilise le composant de récupération de caractéristiques intégré pour générer les données d’entraînement.

Prérequis

Avant de poursuivre ce tutoriel, veillez à suivre le premier de la série.

Configurer

Configurez le notebook Spark Azure Machine Learning.

Vous pouvez créer un nouveau notebook et exécuter étape par étape les instructions contenues dans ce tutoriel. Vous pouvez également ouvrir et exécuter le notebook existant nommé 2.Experiment-train-models-using-features.ipynb 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 le menu supérieur, dans la liste déroulante Calcul, sélectionnez Calcul Spark serverless sous Azure Machine Learning Serverless Spark.
2. Configurer la session :
  1. Lorsque la barre d’outils affiche Configurer la session, sélectionnez cette option.
  2. Sous l’onglet Packages Python, sélectionnez Charger le fichier Conda.
  3. Chargez le fichier conda.yml que vous avez chargé dans le premier tutoriel.
  4. Vous pouvez 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.

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

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

Configurez l’interface CLI.
- Kit de développement logiciel (SDK) Python
- Azure CLI
Non applicable.
1. Installez l’extension Azure Machine Learning.
```
!az extension add --name ml
```
2. S’authentifier.
```
!az login
```
3. Définissez l’abonnement par défaut.
```
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```

Initialisez les variables de l’espace de travail du projet.

Il s’agit de l’espace de travail actuel, et le notebook du tutoriel s’exécute dans cette ressource.

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

Initialisez les variables du magasin de caractéristiques.

Veillez à mettre à jour les valeurs featurestore_name et featurestore_location, en fonction de ce que vous avez créé dans le premier tutoriel.

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

Initialisez le client de consommation du magasin de 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,
)

Créez un cluster de calcul nommé cpu-cluster dans l’espace de travail du projet.

Vous avez besoin de ce cluster de calcul lors de l’exécution des travaux d’entraînement/d’inférence par lots.

from azure.ai.ml.entities import AmlCompute

cluster_basic = AmlCompute(
    name="cpu-cluster-fs",
    type="amlcompute",
    size="STANDARD_F4S_V2",  # you can replace it with other supported VM SKUs
    location=ws_client.workspaces.get(ws_client.workspace_name).location,
    min_instances=0,
    max_instances=1,
    idle_time_before_scale_down=360,
)
ws_client.begin_create_or_update(cluster_basic).result()

Créer l’ensemble de caractéristiques des comptes dans un environnement local

Dans le premier tutoriel, vous avez créé un ensemble de caractéristiques transactions qui présentait des transformations personnalisées. Ici, vous allez créer ensemble de caractéristiques accounts qui utilise des valeurs précalculées.

Pour intégrer des caractéristiques précalculées, vous pouvez créer une spécification d’ensemble de caractéristiques sans écrire le moindre code de transformation. Vous allez utiliser une spécification d’ensemble de caractéristiques pour développer et tester un ensemble de caractéristiques dans un environnement de développement entièrement local.

Vous n’avez pas besoin de vous connecter à un magasin de caractéristiques. Dans le cadre de cette procédure, vous allez créer localement la spécification d’ensemble de caractéristiques, puis vous échantillonnerez les valeurs à partir de celle-ci. Pour tirer parti des capacités d’un magasin de fonctionnalités géré, vous devez utiliser une définition de ressource de caractéristique pour inscrire la spécification d’ensemble de caractéristiques auprès d’un magasin de fonctionnalités. Les étapes ultérieures de ce tutoriel fournissent plus de détails.

Explorer les données sources pour accounts.

Remarque

Ce notebook utilise des exemples de données hébergées dans un conteneur d’objets blob accessible publiquement. Seul un pilote wasbs peut le lire dans Spark. Quand vous créez des ensembles de caractéristiques en utilisant vos propres données sources, hébergez ces ensembles de caractéristiques dans un compte Azure Data Lake Storage Gen2 et utilisez un pilote abfss dans le chemin des données.
```
accounts_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet"
accounts_df = spark.read.parquet(accounts_data_path)

display(accounts_df.head(5))
```

Créez la spécification d’ensemble de caractéristiques accounts localement à partir de ces caractéristiques précalculées.

Vous n’avez pas ici besoin de code de transformation, car vous faites référence à des caractéristiques précalculées.

from azureml.featurestore import create_feature_set_spec, FeatureSetSpec
from azureml.featurestore.contracts import (
    DateTimeOffset,
    Column,
    ColumnType,
    SourceType,
    TimestampColumn,
)
from azureml.featurestore.feature_source import ParquetFeatureSource


accounts_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
    ),
    index_columns=[Column(name="accountID", type=ColumnType.string)],
    # account profiles in the source are updated once a year. set temporal_join_lookback to 365 days
    temporal_join_lookback=DateTimeOffset(days=365, hours=0, minutes=0),
    infer_schema=True,
)

Exportez en tant que spécification d’ensemble de caractéristiques.

Pour inscrire la spécification d’ensemble de caractéristiques auprès du magasin de caractéristiques, vous devez enregistrer cette spécification dans un format spécifique.

Après avoir exécuté la cellule suivante, inspectez la spécification d’ensemble de caractéristiques accounts générée. Pour voir la spécification, ouvrez le fichier featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml à partir de l’arborescence de fichiers.

La spécification contient les éléments importants suivants :
- source : référence à une ressource de stockage. Dans le cas présent, il s’agit d’un fichier Parquet dans une ressource de stockage blob.
- features : une liste de fonctionnalités et de leur type de données. Avec le code de transformation fourni, le code doit retourner un DataFrame qui correspond aux caractéristiques et aux types de données. Sans le code de transformation fourni, le système génère la requête pour mapper les caractéristiques et les types de données à la source. Dans ce cas, la spécification d’ensemble de caractéristiques accounts générée ne contient pas le code de transformation, car les spécifications sont précalculées.
- index_columns : clés de jointure nécessaires pour accéder aux valeurs à partir de l’ensemble de caractéristiques.
Pour plus d’informations, consultez Comprendre les entités de niveau supérieur dans un magasin de fonctionnalités géré et les ressources schéma YAML de la spécification d’ensemble de caractéristiques CLI (v2).

En guise d’avantage supplémentaire, la persistance prend en charge le contrôle de code source.

Vous n’avez pas ici besoin de code de transformation, car vous faites référence à des caractéristiques précalculées.
```
import os

# create a new folder to dump the feature set spec
accounts_featureset_spec_folder = root_dir + "/featurestore/featuresets/accounts/spec"

# check if the folder exists, create one if not
if not os.path.exists(accounts_featureset_spec_folder):
    os.makedirs(accounts_featureset_spec_folder)

accounts_featureset_spec.dump(accounts_featureset_spec_folder, overwrite=True)
```

Réalisez des expériences locales avec des caractéristiques non inscrites et procédez à l’inscription auprès d’un magasin de caractéristiques quand vous êtes prêt

Lorsque vous développez des caractéristiques, vous souhaiterez peut-être les tester et les valider localement, avant de les inscrire auprès du magasin de caractéristiques ou d’exécuter des pipelines d’entraînement dans le cloud. La combinaison d’un ensemble de caractéristiques non inscrit local (accounts) et d’un ensemble de caractéristiques inscrit dans le magasin de caractéristiques (transactions) génère des données d’entraînement pour le modèle Machine Learning.

Sélectionnez des caractéristiques pour le modèle.

# get the registered transactions feature set, version 1
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
# Notice that account feature set spec is in your local dev environment (this notebook): not registered with feature store yet
features = [
    accounts_featureset_spec.get_feature("accountAge"),
    accounts_featureset_spec.get_feature("numPaymentRejects1dPerUser"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
    transactions_featureset.get_feature("transaction_amount_7d_avg"),
]

Générez localement des données d’entraînement.

Cette étape consiste à générer des données d’entraînement à des fins d’illustration. Si vous le souhaitez, vous pouvez entraîner des modèles localement. L’entraînement d’un modèle dans le cloud est expliqué plus tard dans ce tutoriel.

from azureml.featurestore import get_offline_features

# Load the observation data. To understand observatio ndata, refer to part 1 of this tutorial
observation_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"
observation_data_df = spark.read.parquet(observation_data_path)
obs_data_timestamp_column = "timestamp"

# 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: display(training_df.head(5)) displays the timestamp column in a different format. You can can call training_df.show() to see correctly formatted value

Inscrivez l’ensemble de caractéristiques accounts auprès du magasin de caractéristiques.

Une fois que vous avez expérimenté localement des définitions de caractéristiques et qu’elles vous semblent raisonnables, vous pouvez inscrire une définition de ressource d’ensemble de caractéristiques auprès du magasin de caractéristiques.

from azure.ai.ml.entities import FeatureSet, FeatureSetSpecification

accounts_fset_config = FeatureSet(
    name="accounts",
    version="1",
    description="accounts featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=accounts_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

poller = fs_client.feature_sets.begin_create_or_update(accounts_fset_config)
print(poller.result())

Obtenez l’ensemble de caractéristiques inscrit et testez-le.

# look up the featureset by providing name and version
accounts_featureset = featurestore.feature_sets.get("accounts", "1")

Réaliser une expérience d’apprentissage

Dans ces étapes, vous sélectionnez une liste de caractéristiques, exécutez un pipeline d’entraînement et inscrivez le modèle. Vous pouvez répéter ces étapes jusqu’à ce que vous soyez satisfait des performances du modèle.

Découvrez éventuellement les caractéristiques à partir de l’interface utilisateur du magasin de caractéristiques.

Cette étape a été abordée dans le premier tutoriel, au moment où vous avez inscrit l’ensemble de caractéristiques transactions. Comme vous disposez également d’un ensemble de caractéristiques accounts, vous pouvez parcourir les caractéristiques disponibles :
1. Accédez à la page d’arrivée générale d’Azure Machine Learning.
2. Dans le volet de gauche, sélectionnez Magasins de caractéristiques.
3. Dans la liste des magasins de caractéristiques, sélectionnez celui que vous avez créé précédemment.
L’interface utilisateur présente les ensembles de caractéristiques et l’entité de caractéristique que vous avez créés. Sélectionnez les ensembles de caractéristiques pour parcourir les définitions de caractéristiques. Vous pouvez utiliser la zone de recherche globale pour rechercher des ensembles de caractéristiques dans les magasins de caractéristiques.

Découvrez éventuellement des caractéristiques à partir du SDK.

# List available feature sets
all_featuresets = featurestore.feature_sets.list()
for fs in all_featuresets:
    print(fs)

# List of versions for transactions feature set
all_transactions_featureset_versions = featurestore.feature_sets.list(
    name="transactions"
)
for fs in all_transactions_featureset_versions:
    print(fs)

# See properties of the transactions featureset including list of features
featurestore.feature_sets.get(name="transactions", version="1").features

Sélectionnez des caractéristiques pour le modèle, puis exportez ce dernier en tant que spécification de récupération de caractéristiques.

Dans le cadre des étapes précédentes, vous avez sélectionné des caractéristiques à partir d’une combinaison d’ensembles de caractéristiques inscrits et non inscrits, à des fins d’expérimentation et de test en local. Vous pouvez maintenant expérimenter dans le cloud. L’agilité de livraison de votre modèle augmente si vous enregistrez les caractéristiques sélectionnées en tant que spécification de récupération de caractéristiques, puis que vous utilisez la spécification dans les opérations de Machine Learning (MLOps) ou le flux d’intégration continue et de livraison continue (CI/CD) pour l’entraînement et l’inférence.
1. Sélectionnez des caractéristiques pour le modèle.
```
# you can select features in pythonic way
features = [
    accounts_featureset.get_feature("accountAge"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
]

# you can also specify features in string form: featurestore:featureset:version:feature
more_features = [
    f"accounts:1:numPaymentRejects1dPerUser",
    f"transactions:1:transaction_amount_7d_avg",
]

more_features = featurestore.resolve_feature_uri(more_features)

features.extend(more_features)
```
2. Exportez les caractéristiques sélectionnées en tant que spécification de récupération de caractéristiques.
  
  Une spécification de récupération de caractéristiques est une définition portable de la liste de caractéristiques associée à un modèle. Elle peut vous aider à simplifier le développement et l’opérationnalisation d’un modèle Machine Learning. Elle devient une entrée du pipeline d’entraînement, qui génère les données d’entraînement. Elle est ensuite empaquetée avec le modèle.
  
  La phase d’inférence l’utilise la récupération de caractéristiques pour rechercher les fonctionnalités. Elle intègre toutes les phases du cycle de vie du Machine Learning. Au fil des expérimentations et déploiements, vous pouvez limiter au minimum les modifications du pipeline d’entraînement et d’inférence.
  
  L’utilisation de la spécification de récupération de caractéristiques et du composant de récupération de caractéristiques intégré est facultative. Vous pouvez utiliser directement l’API get_offline_features() comme indiqué précédemment. Le nom de la spécification doit être feature_retrieval_spec.yaml lorsque vous l’empaquetez avec le modèle. De cette façon, le système peut la reconnaître.
```
# Create feature retrieval spec
feature_retrieval_spec_folder = root_dir + "/project/fraud_model/feature_retrieval_spec"

# check if the folder exists, create one if not
if not os.path.exists(feature_retrieval_spec_folder):
    os.makedirs(feature_retrieval_spec_folder)

featurestore.generate_feature_retrieval_spec(feature_retrieval_spec_folder, features)
```

Effectuer l’entraînement dans le cloud en utilisant des pipelines et inscrire le modèle

Dans le cadre de cette procédure, vous allez déclencher manuellement le pipeline d’entraînement. Dans un scénario de production, un pipeline CI/CD pourrait le déclencher, selon les modifications apportées à la spécification de récupération de caractéristiques dans le référentiel source. Vous pouvez inscrire le modèle s’il est satisfaisant.

Exécutez le pipeline d’entraînement

Le pipeline d’entraînement comprend les étapes suivantes :
1. Récupération de caractéristiques : ce composant intégré prend en entrée la spécification de récupération de caractéristiques, les données d’observation et le nom de la colonne d’horodatage. Il génère ensuite les données d’entraînement en tant que sortie. Il exécute ces étapes en tant que travail Spark managé.
2. Entraînement : à partir des données d’entraînement, cette étape entraîne le modèle avant d’en générer un (pas encore inscrit).
3. Évaluation : cette étape vérifie si les performances et la qualité du modèle se trouve en deçà d’un certain seuil. (Dans ce tutoriel, cette étape est un espace réservé présenté en guise d’illustration.)
4. Inscription du modèle : cette étape consiste à inscrire le modèle.
  
  Remarque
  
  Dans le deuxième tutoriel, vous avez exécuté un travail de renvoi afin de matérialiser des données pour l’ensemble de caractéristiques transactions. L’étape de récupération de caractéristiques lit les valeurs de caractéristique à partir du magasin hors connexion pour cet ensemble de caractéristiques. Le comportement est identique, même si vous utilisez l’API get_offline_features().
```
from azure.ai.ml import load_job  # will be used later

training_pipeline_path = (
    root_dir + "/project/fraud_model/pipelines/training_pipeline.yaml"
)
training_pipeline_definition = load_job(source=training_pipeline_path)
training_pipeline_job = ws_client.jobs.create_or_update(training_pipeline_definition)
ws_client.jobs.stream(training_pipeline_job.name)
# Note: First time it runs, each step in pipeline can take ~ 15 mins. However subsequent runs can be faster (assuming spark pool is warm - default timeout is 30 mins)
```
5. Inspectez le pipeline d’entraînement et le modèle.
  - Pour afficher les étapes du pipeline, sélectionnez le lien hypertexte pour le pipeline Affichage web, puis ouvrez-le dans une nouvelle fenêtre.
Utilisez la spécification de récupération de caractéristiques dans les artefacts du modèle :
1. Dans le volet gauche de l’espace de travail actuel, sélectionnez Modèles à l’aide du bouton droit de la souris.
2. Sélectionnez Ouvrir dans un nouvel onglet ou une nouvelle fenêtre.
3. Sélectionnez fraud_model.
4. Sélectionnez Artefacts.
La spécification de récupération de caractéristiques est empaquetée avec le modèle. L’étape d’inscription du modèle dans le pipeline d’entraînement prend en charge cette étape. Vous avez créé la spécification de récupération de caractéristiques pendant l’expérimentation. Elle fait désormais partie de la définition du modèle. Dans le tutoriel suivant, vous verrez comment le processus d’inférence l’utilise.

Voir les dépendances des ensembles de caractéristiques et du modèle

Affichez la liste des ensembles de caractéristiques associés au modèle.

Sur la même page Modèles, sélectionnez l’onglet Ensembles de fonctionnalités. Cet onglet affiche les ensembles de fonctionnalités transactions et accounts. Ce modèle dépend de ces ensembles de fonctionnalités.
Affichez la liste des modèles qui utilisent les ensembles de caractéristiques :
1. Ouvrez l’interface utilisateur du magasin de caractéristiques (comme expliqué plus haut dans ce tutoriel).
2. Dans le volet de gauche, sélectionnez Ensembles de caractéristiques.
3. Sélectionnez un ensemble de caractéristiques.
4. Sélectionnez l’onglet Modèles.
La spécification de récupération de caractéristiques a déterminé cette liste au moment où le modèle a été inscrit.

Nettoyage

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

Étapes suivantes

Accédez au tutoriel suivant de la série : Activer la matérialisation récurrente et exécuter l’inférence par lots.
Découvrez les concepts du magasin de caractéristiques et les entités de niveau supérieur d’un magasin de caractéristiques géré.
En savoir plus sur l’identité et le contrôle d’accès pour un magasin de fonctionnalités géré.
Consultez le guide de résolution des problèmes pour magasin de fonctionnalités géré.
Affichez la référence YAML.

Partager via