Partager via

Tutoriel°1 : Développer et inscrire un ensemble de fonctionnalités auprès du magasin de fonctionnalités géré

  • Article

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.

Vous pouvez utiliser un magasin de fonctionnalités géré d’Azure Machine Learning pour découvrir, créer et opérationnaliser des fonctionnaltés. Le cycle de vie du machine learning comprend une phase de prototypage, où vous pouvez expérimenter différentes fonctionnalités. Il comprend également une phase d’opérationnalisation, où les modèles sont déployés et où les étapes d’inférence recherchent des données de fonctionnalités. Les caractéristiques servent de tissu conjonctif dans le cycle de vie du machine learning. Pour plus d’informations sur les concepts de base du magasin de fonctionnalités géré, consultez Présentation du magasin de fonctionnalités géré et Compréhension des entités de niveau supérieur dans le magasin de fonctionnalités géré.

Ce tutoriel explique comment créer une spécification d’ensemble de fonctionnalités avec des transformations personnalisées. Il utilise ensuite cet ensemble de fonctionnalités pour générer des données d’entraînement, activer la matérialisation et effectuer un remplissage. La matérialisation calcule les valeurs de fonctionnalité pour une fenêtre de fonctionnalité, puis stocke ces valeurs dans un magasin de matérialisation. Toutes les requêtes de fonctionnalités peuvent ensuite utiliser ces valeurs à partir du magasin de matérialisation.

Sans la matérialisation, une requête d’ensemble de fonctionnalités applique les transformations à la source à la volée pour calculer les fonctionnalités avant de retourner les valeurs. Ce processus fonctionne bien pour la phase de prototypage. Toutefois, pour les opérations d’entraînement et d’inférence dans un environnement de production, nous vous recommandons de matérialiser les fonctionnalités, pour une fiabilité et une disponibilité accrues.

Ce tutoriel constitue la première partie de la série de tutoriels sur le magasin de fonctionnalités géré. Ici, vous découvrirez comment :

  • Créer une ressource minimale de magasin de fonctionnalités.
  • Développer et tester localement un ensemble de fonctionnalités avec la capacité de transformation de fonctionnalités.
  • Inscrire une entité de magasin de caractéristiques auprès du magasin de caractéristiques.
  • Inscrire l’ensemble de fonctionnalités que vous avez développé auprès du magasin de fonctionnalités.
  • Générer un exemple de DataFrame d’apprentissage en utilisant les fonctionnalités que vous avez créées.
  • Activez la matérialisation hors connexion sur les ensembles de fonctionnalités et renvoyez les données de fonctionnalités.

Cette série de didacticiels comporte deux pistes :

  • La piste SDK uniquement utilise uniquement les SDK Python. Choisissez cette piste pour le développement et le déploiement purs basés sur Python.
  • La piste SDL et interface CLI utilise le SDK Python pour le développement et le test d’ensembles de fonctionnalités uniquement, et l’interface CLI pour les opérations CRUD (création, lecture, mise à jour et suppression). Cette piste est utile dans les scénarios d’intégration continue et de livraison continue (CI/CD) ou GitOps, où CLI/YAML est préférable.

Prérequis

Avant de continuer avec ce tutoriel, assurez-vous de satisfaire à ces prérequis :

  • Un espace de travail Azure Machine Learning. Pour plus d’informations sur la création d’espaces de travail, consultez l’article Démarrage rapide : Créer des ressources d’espace de travail.

  • Sur votre compte d’utilisateur, le rôle Propriétaire pour le groupe de ressources où le magasin de fonctionnalités est créé.

    Si vous souhaitez utiliser un nouveau groupe de ressources pour ce tutoriel, vous pouvez facilement supprimer toutes les ressources en supprimant le groupe de ressources.

Préparer l’environnement de notebook

Ce didacticiel utilise un notebook Spark Azure Machine Learning pour le développement.

  1. Dans l’environnement d’Azure Machine Learning studio, sélectionnez Notebooks dans le volet gauche, puis l’onglet Exemples.

  2. Accédez au répertoire featurestore_sample (sélectionnez Exemples>SDK v2>sdk>python>featurestore_sample), puis Cloner.

    Capture d’écran montrant la sélection du répertoire des exemples dans Azure Machine Learning studio.

  3. Le panneau Sélectionner le répertoire cible s’ouvre. Sélectionnez le répertoire Utilisateurs, puis sélectionnez votre nom d’utilisateur, puis sélectionnez Cloner.

    Capture d’écran montrant la sélection de l’emplacement du répertoire cible dans Azure Machine Learning studio pour l’exemple de ressource.

  4. Pour configurer l’environnement de notebook, vous devez charger le fichier conda.yml :

    1. Sélectionnez Notebooks dans le volet de gauche, puis l’onglet Fichiers.
    2. Accédez au répertoire env (sélectionnez Utilisateurs>your_user_name>featurestore_sample>Projet>env), puis sélectionnez le fichier conda.yml.
    3. Sélectionnez Télécharger.

    Capture d’écran montrant la sélection du fichier YAML Conda dans Azure Machine Learning studio.

    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 indique 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 les fichiers Conda.
    5. Sélectionnez le fichier conda.yml que vous avez téléchargé 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.

  5. Dans l’environnement Azure Machine Learning, ouvrez le notebook, puis sélectionnez Configurer la session.

    Capture d’écran montrant les sélections pour configurer une session pour un notebook.

  6. Dans le panneau Configurer la session, sélectionnez Packages Python.

  7. Chargez le fichier Conda :

    1. Sous l’onglet Packages Python, sélectionnez Charger le fichier Conda.
    2. Accédez au répertoire qui héberge le fichier Conda.
    3. Sélectionnez conda.yml, puis Ouvrir.

    Capture d’écran montrant le répertoire qui héberge le fichier Conda.

  8. Sélectionnez Appliquer.

    Capture d’écran montrant le chargement du fichier Conda.

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

Configurer le répertoire racine pour les exemples

import os

# Please update <your_user_alias> below (or any custom directory you uploaded the samples to).
# You can find the name from the directory structure in the left navigation panel.
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")

Configurer l’interface CLI

Non applicable.

Remarque

Vous utilisez un magasin de fonctionnalités pour réutiliser des fonctionnalités dans plusieurs projets. Vous utilisez un espace de travail de projet (un espace de travail Azure Machine Learning) pour entraîner des modèles d’inférence, en tirant parti des fonctionnalités des magasins de fonctionnalités. De nombreux espaces de travail de projet peuvent partager et réutiliser le même magasin de caractéristiques.

Ce didacticiel utilise deux SDK :

  • SDK CRUD du magasin de fonctionnalités

    Vous utilisez le même SDK MLClient (nom de package azure-ai-ml) que vous utilisez avec l’espace de travail Azure Machine Learning. Un magasin de fonctionnalités est implémenté en tant que type d’espace de travail. Par conséquent, ce SDK est utilisé pour les opérations CRUD des magasins de fonctionnalités, des ensembles de fonctionnalités et des entités de magasin de fonctionnalités.

  • SDK principal du magasin de fonctionnalités

    Ce SDK (azureml-featurestore) est destiné au développement et à la consommation d’ensembles de fonctionnalités. Les étapes ultérieures de ce didacticiel décrivent ces opérations :

    • Développez une spécification de l’ensemble de fonctionnalités.
    • Récupérez des données de fonctionnalité.
    • Répertoriez ou obtenez un ensemble de fonctionnalités inscrit.
    • Générez et résolvez les spécifications de récupération des fonctionnalités.
    • Générer des données d’apprentissage et d’inférence en utilisant des jointures à un point dans le temps.

Ce tutoriel ne nécessite pas l’installation explicite de ces SDK, car les instructions conda.yml précédentes couvrent cette étape.

Créer un magasin minimal de fonctionnalités

  1. Définissez les paramètres du magasin de fonctionnalités, notamment le nom, l’emplacement et d’autres valeurs.

    # We use the subscription, resource group, region of this active project workspace.
# You can optionally replace them to create the resources in a different subsciprtion/resource group, or use existing resources.
import os

featurestore_name = "<FEATURESTORE_NAME>"
featurestore_location = "eastus"
featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

  2. Créez le magasin de fonctionnalités.

    from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    FeatureStore,
    FeatureStoreEntity,
    FeatureSet,
)
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

ml_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    subscription_id=featurestore_subscription_id,
    resource_group_name=featurestore_resource_group_name,
)


fs = FeatureStore(name=featurestore_name, location=featurestore_location)
# wait for feature store creation
fs_poller = ml_client.feature_stores.begin_create(fs)
print(fs_poller.result())

  3. Initialisez le client SDK principal d’un magasin de fonctionnalités pour Azure Machine Learning.

    Comme expliqué précédemment dans ce tutoriel, le client SDK principal du magasin de fonctionnalités est utilisé pour développer et consommer des 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,
)

  4. Accordez le rôle « Scientifique des données Azure Machine Learning » sur le magasin de fonctionnalités à votre identité utilisateur. Obtenez la valeur de votre ID d’objet Microsoft Entra à partir du Portail Azure comme décrit dans Rechercher l’ID d’objet utilisateur.

    Affectez le rôle Scientifique des données AzureML à votre identité utilisateur afin qu’elle puisse créer des ressources dans l’espace de travail du magasin de fonctionnalités. La propagation des autorisations peut nécessiter un certain temps.

    Pour en savoir plus sur le contrôle d’accès, consultez Gérer le contrôle d’accès pour un magasin de fonctionnalités géré.

    your_aad_objectid = "<USER_AAD_OBJECTID>"

!az role assignment create --role "AzureML Data Scientist" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $feature_store_arm_id

Prototyper et développer un ensemble de fonctionnalités

Dans ces étapes, vous créez un ensemble de fonctionnalités nommé transactions qui a des caractéristiques basées sur l’agrégation de fenêtres dynamiques :

  1. Explorez les données sources transactions.

    Ce notebook utilise des exemples de données hébergées dans un conteneur d’objets blob accessible publiquement. Celles-ci peuvent uniquement être lues dans Spark via un pilote wasbs. Quand vous créez des ensembles de fonctionnalités en utilisant vos propres données sources, hébergez-les dans un compte Azure Data Lake Storage Gen2 et utilisez un pilote abfss dans le chemin des données.

    # remove the "." in the roor directory path as we need to generate absolute path to read from spark
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)

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

  2. Développez localement l’ensemble de fonctionnalités.

    Une spécification d’ensemble de fonctionnalités est une définition autonome d’un ensemble de fonctionnalités que vous pouvez développer et tester localement. Ici, vous créez ces fonctionnalités d’agrégation de fenêtres glissantes :

    • transactions three-day count
    • transactions amount three-day sum
    • transactions amount three-day avg
    • transactions seven-day count
    • transactions amount seven-day sum
    • transactions amount seven-day avg

    Passez en revue le fichier de code de transformation de fonctionnalités : featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Notez l’agrégation glissante définie pour les caractéristiques. C’est un transformateur Spark.

    Pour en savoir plus sur l’ensemble de fonctionnalités et les transformations, consultez Qu’est-ce qu’un magasin de fonctionnalités géré ?.

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

transactions_featureset_code_path = (
    root_dir + "/featurestore/featuresets/transactions/transformation_code"
)

transactions_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
        source_delay=DateTimeOffset(days=0, hours=0, minutes=20),
    ),
    feature_transformation=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,
)

  3. Exportez en tant que spécification d’ensemble de fonctionnalités.

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

    Passez en revue la spécification de l’ensemble de fonctionnalités transactions générée. Ouvrez ce fichier à partir de l’arborescence de fichiers pour afficher la spécification : featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml.

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

    • source : une 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. Si vous fournissez du code de transformation, le code doit retourner un DataFrame qui correspond aux caractéristiques et aux types de données.
    • index_columns : les clés de jointure nécessaires pour accéder aux valeurs à partir de l’ensemble de fonctionnalités.

    Pour plus d’informations sur la spécification, consultez Compréhension des entités de niveau supérieur dans un magasin de fonctionnalités géré et Schéma YAML de l’ensemble de fonctionnalités CLI (v2).

    La persistance de la spécification de l’ensemble de fonctionnalités offre un autre avantage : la spécification de l’ensemble de fonctionnalités peut être contrôlée par la source.

    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 it does not exist.
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

À titre de bonne pratique, les entités aident à imposer l’utilisation de la même définition de clé de jointure entre les ensembles de caractéristiques qui utilisent les mêmes entités logiques. Les comptes et les clients sont des exemples d’entités. Les entités sont généralement créées une seule fois, puis réutilisées dans les ensembles de fonctionnalités. Pour en savoir plus, consultez Compréhension des entités de niveau supérieur dans un magasin de fonctionnalités géré.

  1. Initialisez le client CRUD du magasin de fonctionnalités.

    Comme expliqué plus haut dans ce tutoriel, MLClient est utilisé pour créer, lire, mettre à jour et supprimer une ressource de magasin de fonctionnalités. L’extrait de cellule de code de notebook affiché ci-contre recherche le magasin de fonctionnalités que nous avons créé lors d’une étape précédente. Ici, vous ne pouvez pas réutiliser la même valeur ml_client que vous avez utilisée précédemment dans ce tutoriel, car elle est délimitée au niveau du groupe de ressources. Une étendue appropriée est un prérequis à la création d’un magasin de fonctionnalités.

    Dans cet exemple de code, le client est limité au niveau du magasin de fonctionnalités.

    # MLClient for feature store.
fs_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    featurestore_subscription_id,
    featurestore_resource_group_name,
    featurestore_name,
)

  2. Inscrivez l’entité account auprès du magasin de fonctionnalités.

    Créez une entité account qui a la clé de jointure accountID de type string.

    from azure.ai.ml.entities import DataColumn, DataColumnType

account_entity_config = FeatureStoreEntity(
    name="account",
    version="1",
    index_columns=[DataColumn(name="accountID", type=DataColumnType.STRING)],
    stage="Development",
    description="This entity represents user account index key accountID.",
    tags={"data_typ": "nonPII"},
)

poller = fs_client.feature_store_entities.begin_create_or_update(account_entity_config)
print(poller.result())

Inscrire l’ensemble de fonctionnalités des transactions auprès du magasin de fonctionnalités

Utilisez ce code pour inscrire une ressource d’ensemble de fonctionnalités auprès du magasin de fonctionnalités. Vous pouvez ensuite réutiliser cette ressource et la partager facilement. L’inscription d’une ressource d’ensemble de fonctionnalités offre des capacités managées, notamment le contrôle de version et la matérialisation. Les étapes ultérieures de cette série de didacticiels couvrent les fonctionnalités managées.

from azure.ai.ml.entities import FeatureSetSpecification

transaction_fset_config = FeatureSet(
    name="transactions",
    version="1",
    description="7-day and 3-day rolling aggregation of transactions featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=transactions_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

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

Explorer l’interface utilisateur du magasin de caractéristiques

La création et les mises à jour des ressources du magasin de fonctionnalités ne peuvent se produire que via le SDK et l’interface CLI. Vous pouvez utiliser l’interface utilisateur pour rechercher ou naviguer dans le magasin de fonctionnalités :

  1. Ouvrez la page d’accueil générale d’Azure Machine Learning.
  2. Sélectionnez Magasins de fonctionnalités dans le volet de gauche.
  3. Dans la liste de magasins de fonctionnalités accessibles, sélectionnez le magasin de fonctionnalités que vous avez créé précédemment dans ce tutoriel.

Octroyer le rôle Lecteur des données blob du stockage à votre compte d’utilisateur dans le magasin hors connexion

Le rôle Lecteur des données blob du stockage doit être attribué à votre compte d’utilisateur sur le magasin hors connexion. Cela garantit que le compte d’utilisateur peut lire les données de fonctionnalités matérialisées à partir du magasin de matérialisation hors connexion.

  1. Obtenez la valeur de votre ID d’objet Microsoft Entra à partir du Portail Azure comme décrit dans Rechercher l’ID d’objet utilisateur.

  2. Obtenez des informations sur le magasin de matérialisation hors connexion à partir de la page Vue d’ensemble du magasin de fonctionnalités dans l’interface utilisateur du magasin de fonctionnalités. Vous trouverez les valeurs de l’ID d’abonnement du compte de stockage, du nom du groupe de ressources du compte de stockage et du nom du compte de stockage pour le magasin de matérialisation hors connexion dans la carte Magasin de matérialisation hors connexion.

    Capture d’écran montrant les informations de compte de magasin hors connexion sur la page Vue d’ensemble du magasin de fonctionnalités.

    Pour en savoir plus sur le contrôle d’accès, consultez Gérer le contrôle d’accès pour un magasin de fonctionnalités géré.

    Exécutez cette cellule de code pour l’attribution de rôle. La propagation des autorisations peut nécessiter un certain temps.

    # This utility function is created for ease of use in the docs tutorials. It uses standard azure API's.
# You can optionally inspect it `featurestore/setup/setup_storage_uai.py`.
import sys

sys.path.insert(0, root_dir + "/featurestore/setup")
from setup_storage_uai import grant_user_aad_storage_data_reader_role

your_aad_objectid = "<USER_AAD_OBJECTID>"
storage_subscription_id = "<SUBSCRIPTION_ID>"
storage_resource_group_name = "<RESOURCE_GROUP>"
storage_account_name = "<STORAGE_ACCOUNT_NAME>"

grant_user_aad_storage_data_reader_role(
    AzureMLOnBehalfOfCredential(),
    your_aad_objectid,
    storage_subscription_id,
    storage_resource_group_name,
    storage_account_name,
)

Générer un DataFrame de données d’apprentissage en utilisant l’ensemble de fonctionnalités inscrit

  1. Chargez les données d’observation.

    Les données d’observation comprennent généralement les données de base utilisées pour l’entraînement et l’inférence. Ces données sont jointes aux données des fonctionnalités pour créer une ressource de données d’entraînement complètes.

    Les données d’observation sont des données capturées pendant l’événement lui-même. Ici, elles contiennent des données de base des transactions, dont les valeurs de l’ID de transaction, de l’ID de compte et du montant de la transaction. Comme vous les utilisez pour l’apprentissage, elles contiennent également une variable cible (is_fraud) ajoutée.

    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"

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

  2. Obtenez l’ensemble de fonctionnalités inscrit et répertoriez ses fonctionnalités.

    # Look up the featureset by providing a name and a 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))

  3. Sélectionnez les fonctionnalités qui deviennent partie des données d’apprentissage. Ensuite, utilisez le SDK du magasin de fonctionnalités pour générer les données d’apprentissage proprement dites.

    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: featureset:version:feature.
more_features = [
    f"transactions:1:transaction_3d_count",
    f"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 subsequent 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 ajoute les caractéristiques aux données d’entraînement.

Activer la matérialisation hors connexion sur l’ensemble de fonctionnalités transactions

Une fois la matérialisation de l’ensemble de fonctionnalités activée, vous pouvez effectuer un remplissage. Vous pouvez également planifier des tâches de matérialisation récurrentes. Pour plus d’informations, consultez le troisième tutoriel de cette série.

Définir spark.sql.shuffle.partitions dans le fichier yaml en fonction de la taille des données de fonctionnalité

La configuration spark spark.sql.shuffle.partitions est un paramètre FACULTATIF qui peut affecter le nombre de fichiers Parquet générés (par jour) lorsque l’ensemble de fonctionnalités est matérialisé dans le magasin hors connexion. La valeur par défaut de ce paramètre est 200. La meilleure pratique consiste à éviter de générer un grand nombre de petits fichiers Parquet. Si la récupération des fonctionnalités hors connexion devient lente après la matérialisation de l’ensemble de fonctionnalités, accédez au dossier correspondant dans le magasin hors connexion pour vérifier si le problème implique trop de petits fichiers Parquet (par jour) et ajustez la valeur de ce paramètre en conséquence.

Remarque

L’exemple de données utilisé dans ce notebook est petit. Par conséquent, ce paramètre est défini sur 1 dans le fichier featureset_asset_offline_enabled.yaml.

from azure.ai.ml.entities import (
    MaterializationSettings,
    MaterializationComputeResource,
)

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

transactions_fset_config.materialization_settings = MaterializationSettings(
    offline_enabled=True,
    resource=MaterializationComputeResource(instance_type="standard_e8s_v3"),
    spark_configuration={
        "spark.driver.cores": 4,
        "spark.driver.memory": "36g",
        "spark.executor.cores": 4,
        "spark.executor.memory": "36g",
        "spark.executor.instances": 2,
        "spark.sql.shuffle.partitions": 1,
    },
    schedule=None,
)

fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)
print(fs_poller.result())

Vous pouvez également enregistrer la ressource de l’ensemble de fonctionnalités en tant que ressource YAML.

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

Données de remplissage pour l’ensemble de fonctionnalités transactions

Comme expliqué précédemment, la matérialisation calcule les valeurs de fonctionnalité d’une fenêtre de fonctionnalité et stocke ces valeurs calculées dans un magasin de matérialisation. La matérialisation des fonctionnalités augmente la fiabilité et la disponibilité des valeurs calculées. Toutes les requêtes de fonctionnalités utilisent désormais les valeurs du magasin de matérialisation. Cette étape effectue un remplissage unique pour une fenêtre de fonctionnalité de 18 mois.

Remarque

Vous devrez peut-être déterminer une valeur de fenêtre de données de remplissage. La fenêtre doit correspondre à la fenêtre de vos données d’entraînement. Par exemple, pour utiliser 18 mois de données pour l’entraînement, vous devez récupérer les fonctionnalités pour 18 mois. Cela signifie que vous devez remplir une fenêtre de 18 mois.

Cette cellule de code matérialise les données selon l’état actuel Aucun ou Incomplet pour la fenêtre de fonctionnalité définie.

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

st = datetime(2022, 1, 1, 0, 0, 0, 0)
et = datetime(2023, 6, 30, 0, 0, 0, 0)

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version="1",
    feature_window_start_time=st,
    feature_window_end_time=et,
    data_status=[DataAvailabilityStatus.NONE],
)
print(poller.result().job_ids)
# Get the job URL, and stream the job logs.
fs_client.jobs.stream(poller.result().job_ids[0])

Conseil

  • La colonne timestamp doit suivre le format yyyy-MM-ddTHH:mm:ss.fffZ.
  • La précision de feature_window_start_time et feature_window_end_time est limitée à quelques secondes. Toutes les millisecondes fournies dans l’objet datetime sont ignorées.
  • Un travail de matérialisation est envoyé uniquement si des données dans la fenêtre de fonctionnalité correspondent à l’élément data_status défini lors de l’envoi du travail de remplissage.

Imprimez des exemples de données à partir de l’ensemble de fonctionnalités. Les informations de sortie montrent que les données ont été récupérées à partir du magasin de matérialisation. La méthode get_offline_features() a récupéré les données d’apprentissage et d’inférence. Elle utilise également le magasin de matérialisation par défaut.

# Look up the feature set by providing a name and a version and display few records.
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
display(transactions_featureset.to_spark_dataframe().head(5))

Explorer davantage la matérialisation des fonctionnalités hors connexion

Vous pouvez explorer l’état de matérialisation des fonctionnalités d’un ensemble de fonctionnalités dans l’interface utilisateur des travaux de matérialisation.

  1. Ouvrez la page d’accueil générale d’Azure Machine Learning.

  2. Sélectionnez Magasins de fonctionnalités dans le volet de gauche.

  3. Dans la liste de magasins de fonctionnalités accessibles, sélectionnez le magasin de fonctionnalités pour lequel vous avez effectué le remplissage.

  4. Sélectionnez l’onglet Travaux de matérialisation.

    Capture d’écran montrant l’interface utilisateur des travaux Matérialisation du jeu de fonctionnalités.

  • L’état de matérialisation des données peut être

    • Complet (vert)
    • Incomplet (rouge)
    • En attente (bleu)
    • Aucun (gris)

  • Un intervalle de données représente une partie contiguë des données avec le même état de matérialisation. Par exemple, l’instantané précédent comporte 16 intervalles de données dans le magasin de matérialisation hors connexion.

  • Les données peuvent avoir un maximum de 2 000 intervalles de données. Si vos données contiennent plus de 2 000 intervalles de données, créez une autre version de l’ensemble de fonctionnalités.

  • Vous pouvez fournir une liste de plusieurs états de données (par exemple, ["None", "Incomplete"]) dans un travail de remplissage unique.

  • Pendant le remplissage, un nouveau travail de matérialisation est envoyé pour chaque intervalle de données qui se situe dans la fenêtre de fonctionnalité définie.

  • Si un travail de matérialisation est en attente ou que ce travail s’exécute pour un intervalle de données qui n’a pas encore été rempli, un nouveau travail n’est pas envoyé pour cet intervalle de données.

  • Vous pouvez réessayer un travail de matérialisation ayant échoué.

    Remarque

    Pour obtenir l’ID d’un travail de matérialisation ayant échoué :

    • Accédez à l’interface utilisateur des travaux de matérialisation de l’ensemble de fonctionnalités.
    • Sélectionnez le nom d’affichage d’un travail spécifique avec l’état Échec.
    • Recherchez l’ID de travail sous la propriété Nom trouvée dans la page Vue d’ensemble du travail. Elle commence par Featurestore-Materialization- .

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version=version,
    job_id="<JOB_ID_OF_FAILED_MATERIALIZATION_JOB>",
)
print(poller.result().job_ids)

Mise à jour du magasin de matérialisation hors connexion

  • Si un magasin de matérialisation hors connexion doit être mis à jour au niveau du magasin de fonctionnalités, tous les ensembles de fonctionnalités du magasin de fonctionnalités doivent avoir la matérialisation hors connexion désactivée.
  • Si la matérialisation hors connexion est désactivée sur un ensemble de fonctionnalités, l’état de matérialisation des données déjà matérialisées dans le magasin de matérialisation hors connexion est réinitialisé. La réinitialisation rend les données déjà matérialisées inutilisables. Vous devez renvoyer les travaux de matérialisation après avoir activé la matérialisation hors connexion.

Ce tutoriel a créé les données d’entraînement avec des fonctionnalités du magasin de fonctionnalités, activé la matérialisation pour le magasin de fonctionnalités hors connexion et effectué un remplissage. Ensuite, vous allez exécuter l’entraînement du modèle à l’aide de ces fonctionnalités.

Nettoyage

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

Étapes suivantes