Tutoriel sur le magasin de fonctionnalités managé 1 : Développer et inscrire un ensemble de fonctionnalités

Dans cette série de tutoriels, vous allez apprendre à utiliser le magasin de fonctionnalités managés pour découvrir, créer et opérationnaliser des fonctionnalités Azure Machine Learning. Les fonctionnalités intègrent en toute transparence les phases de prototypage, d’entraînement et d’opérationnalisation du cycle de vie du Machine Learning.

Dans la phase de prototypage, vous expérimentez différentes fonctionnalités et, dans la phase d’opérationnalisation, vous déployez des modèles qui utilisent des étapes d’inférence pour rechercher des données de caractéristiques. Les fonctionnalités servent de tissu conjonctif dans le cycle de vie.

Vous utilisez un espace de travail de projet Azure Machine Learning pour entraîner des modèles d’inférence à l’aide de fonctionnalités provenant de magasins de fonctionnalités. De nombreux espaces de travail de projet peuvent partager et réutiliser le même magasin de caractéristiques. Pour plus d’informations sur le magasin de fonctionnalités managé, consultez Présentation du magasin de fonctionnalités managé et comprendre les entités de niveau supérieur dans le magasin de fonctionnalités managé.

Conditions préalables

• Un espace de travail Azure Machine Learning. Pour plus d’informations sur la création de l’espace de travail, consultez Démarrage rapide : Créer des ressources d’espace de travail.
• Rôle propriétaire sur le groupe de ressources où le magasin de fonctionnalités est créé.

Parcours de tutoriels SDK + CLI ou SDK uniquement

Cette série de tutoriels utilise un notebook Azure Machine Learning Spark pour le développement. Vous pouvez choisir entre deux pistes pour terminer la série de tutoriels, en fonction de vos besoins.

• La piste SDK + CLI utilise le Kit de développement et de test Python pour le développement et le test des ensembles de fonctionnalités, et utilise Azure CLI pour créer, lire, mettre à jour et supprimer (CRUD). Cette piste est utile pour l’intégration continue et la livraison continue (CI/CD) ou les scénarios GitOps qui utilisent l’interface CLI et YAML.

• Le parcours SDK uniquement utilise exclusivement des SDK Python. Ce parcours offre un développement et un déploiement purs basés sur Python.

Vous sélectionnez une piste en ouvrant le bloc-notes dans le dossier cli_and_sdk ou sdk_only de votre bloc-notes cloné. Suivez les instructions de l’onglet correspondant dans les didacticiels.

Tutoriel 1 : Développer et inscrire un ensemble de fonctionnalités

Ce premier tutoriel décrit la création d’une spécification d’ensemble de fonctionnalités avec des transformations personnalisées. Vous utilisez ensuite cet ensemble de fonctionnalités pour générer des données d’apprentissage, activer la matérialisation et effectuer un remplissage. Vous apprenez à :

Cloner le bloc-notes

1. Dans Azure Machine Learning Studio, sélectionnez Notebooks dans le menu de navigation de gauche, puis sélectionnez l’onglet Exemples dans la page Notebooks .

2. Développez les dossiersSDK v2>sdk>python, cliquez avec le bouton droit sur le dossier featurestore_sample, puis sélectionnez Cloner.

   

3. Dans le volet Sélectionner un répertoire cible, vérifiez que Usersyour_usernamefeaturestore_sample s’affichent, puis sélectionnez Cloner. Le référentiel featurestore_sample est cloné dans le répertoire utilisateur de votre espace de travail.

4. Accédez à votre bloc-notes cloné sous l’onglet Fichiers de la page Bloc-notes , puis développez Utilisateurs><your_username>>featurestore_sample>projet>env.

5. Cliquez avec le bouton droit sur le fichier conda.yml et sélectionnez Télécharger pour le télécharger sur votre ordinateur. Vous pouvez donc le charger ultérieurement dans l’environnement serveur.

   

Préparer et démarrer le notebook

1. Dans le volet gauche de l’onglet Fichiers, développez featurestore_sample>notebooks>sdk_and_cli ou sdk_only, en fonction du suivi que vous souhaitez exécuter.

2. Ouvrez le premier chapitre du didacticiel en le sélectionnant.

3. Dans la zone supérieure droite de la page Bloc-notes, sélectionnez la flèche déroulante en regard de Calcul, puis sélectionnez Calcul Spark sans serveur - Disponible. L’attachement du calcul peut prendre une ou deux minutes.

4. Dans la barre supérieure au-dessus du fichier notebook, sélectionnez Configurer la session.

   

5. Dans l’écran Configurer la session , sélectionnez packages Python dans le volet gauche.

6. Sélectionnez Charger le fichier conda, puis, sous Sélectionner un fichier conda, accédez au fichier conda.yml que vous avez téléchargé.

7. Si vous le souhaitez, sélectionnez Paramètres dans le volet gauche et augmentez la durée du délai d’expiration de session pour empêcher le délai d’attente du démarrage Spark serverless.

8. Sélectionnez Appliquer.

   

Démarrer le bloc-notes

Créer un magasin de caractéristiques minimal.

1. Définir les paramètres du magasin de caractéristiques, notamment le nom, l’emplacement et les autres valeurs. Ajoutez une <FEATURESTORE_NAME>, puis exécutez la cellule.

   # 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éer le magasin de caractéristiques.

   • Piste SDK et interface CLI
   • Suivi du Kit de développement logiciel (SDK

   !az ml feature-store create --subscription $featurestore_subscription_id --resource-group $featurestore_resource_group_name --location $featurestore_location --name $featurestore_name

3. Initialiser un client SDK principal du magasin de caractéristiques pour Azure Machine Learning. Le client 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. Attribuer à votre identité utilisateur le rôle AzureML Data Scientist sur le magasin de caractéristiques. Obtenez votre valeur d’ID d’objet Microsoft Entra à partir du portail Azure, comme décrit dans Rechercher l’ID d’objet utilisateur.

5. Exécutez la cellule suivante pour affecter 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. Remplacez l'espace réservé <USER_AAD_OBJECTID> avec votre ID d'objet Microsoft Entra. La propagation des autorisations peut prendre un certain temps.

   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

   Pour plus d’informations sur le contrôle d’accès, consultez Gérer le contrôle d’accès pour le magasin de fonctionnalités managé.

Prototyper et développer un jeu de caractéristiques.

Ce notebook utilise des données d’exemple hébergées dans un conteneur Blob accessible publiquement, lisibles dans Spark uniquement via un pilote wasbs. Si vous créez des jeux de fonctionnalités à l’aide de vos propres données sources, hébergez-les dans un compte Azure Data Lake Storage et utilisez un abfss pilote dans le chemin de données.

Explorer les données sources des transactions

Créer un jeu de caractéristiques nommé transactions comprenant des caractéristiques basées sur des agrégats en fenêtre glissante.

# 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

Développer localement l’ensemble de fonctionnalités

Une spécification de jeu de caractéristiques est une définition autonome que vous pouvez développer et tester localement. Créez les caractéristiques d’agrégation de fenêtres glissantes suivantes :

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

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

Passez en revue le fichier de code de transformation de fonctionnalité : featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Notez l’agrégation glissante définie pour les caractéristiques. Ce fichier est un transformateur Spark. Pour plus d’informations sur l’ensemble de fonctionnalités et les transformations, consultez Qu’est-ce que le magasin de fonctionnalités géré ?

Exporter en tant que spécification d’ensemble de fonctionnalités

Pour enregistrer la spécification du jeu de caractéristiques dans le magasin, vous devez l’enregistrer à un emplacement et dans un format spécifiques, compatibles avec le contrôle de 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)

Pour afficher la spécification featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml , ouvrez la spécification du jeu de fonctionnalités généré transactions à partir de l’arborescence de fichiers. La spécification contient les éléments suivants :

• source : une référence à une ressource de stockage. Dans le cas présent, c’est un fichier parquet dans une ressource de stockage blob.
• features : une liste de caractéristiques et de leurs types de données. Si vous fournissez du code de transformation, celui-ci doit retourner un DataFrame correspondant aux caractéristiques et à leurs types.
• index_columns : les clés de jointure nécessaires pour accéder aux valeurs du jeu de caractéristiques.

Enregistrer une entité de magasin de caractéristiques.

Les entités permettent d’appliquer la meilleure pratique d’utiliser la même définition de clé de jointure entre les jeux de fonctionnalités qui utilisent les mêmes entités logiques. Exemples d’entités incluent accounts et customers. Les entités sont généralement créées une seule fois puis réutilisées dans plusieurs jeux de caractéristiques. Pour en savoir plus, consultez Comprendre les entités de niveau supérieur dans le magasin de caractéristiques managé.

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 --feature-store-name $featurestore_name

Inscrire l’ensemble de caractéristiques dans le répertoire de fonctionnalités

Le code suivant enregistre un asset de jeu de caractéristiques dans le magasin. Vous pouvez ensuite réutiliser cet asset et le partager facilement. L’enregistrement d’un asset de jeu de caractéristiques fournit des fonctionnalités managées, notamment le versioning et la matérialisation. Les didacticiels ultérieurs de cette série couvrent les fonctionnalités managées.

account_featureset_path = (
    root_dir + "/featurestore/featuresets/transactions/featureset_asset.yaml"
)
!az ml feature-set create --file $account_featureset_path --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

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 la mise à jour des assets de jeux de caractéristiques ne peuvent se faire que via le SDK et la CLI. Vous pouvez utiliser l’interface utilisateur Machine Learning pour rechercher ou parcourir le magasin de fonctionnalités.

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

Attribuer le rôle de lecteur de données de blob de stockage

Le rôle Storage Blob Data Reader doit être attribué à votre compte utilisateur afin de lui permettre de lire les données matérialisées depuis le magasin hors ligne.

Obtenez des informations sur le magasin de matérialisation hors connexion depuis la page Vue d’ensemble de l'interface utilisateur du Feature Store. Les valeurs du compte de stockage <SUBSCRIPTION_ID>, du compte de stockage <RESOURCE_GROUP> et de <STORAGE_ACCOUNT_NAME> pour le magasin de matérialisation hors ligne se trouvent dans la carte Magasin de matérialisation hors ligne.

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

# Set the ADLS Gen2 storage account ARM ID
gen2_storage_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}".format(
    sub_id=storage_subscription_id,
    rg=storage_resource_group_name,
    account=storage_account_name,
)

print(gen2_storage_arm_id)

!az role assignment create --role "Storage Blob Data Reader" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $gen2_storage_arm_id

Pour plus d’informations sur le contrôle d’accès, consultez Gérer le contrôle d’accès pour le magasin de fonctionnalités managé.

Générer un DataFrame de données d’apprentissage

Générez un DataFrame de données d'entraînement à l’aide de l'ensemble de caractéristiques inscrit.

1. Chargez les données d’observation capturées pendant l’événement lui-même.

   Les données d’observation impliquent généralement les données de base utilisées pour l’apprentissage et l’inférence, qui se joint aux données de fonctionnalité pour créer la ressource complète de données d’apprentissage. Les données suivantes incluent des données de transaction essentielles, comme l’ID de transaction, l’ID de compte, et les montants des transactions. Étant donné que vous utilisez les données pour l’entraînement, elles ont également une variable is_fraudcible 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. Récupérer le jeu de caractéristiques enregistré et lister ses caractéristiques.

   # 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 pour faire partie des données d’apprentissage et utilisez le Kit de développement logiciel (SDK) du magasin de fonctionnalités pour générer les données d’apprentissage elles-mêmes. Une jointure à un point dans le temps ajoute les caractéristiques aux données d’entraînement.

   from azureml.featurestore import get_offline_features
   
   # You can select features in pythonic way.
   features = [
       transactions_featureset.get_feature("transaction_amount_7d_sum"),
       transactions_featureset.get_feature("transaction_amount_7d_avg"),
   ]
   
   # You can also specify features in string form: 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

Activer la matérialisation hors connexion

La matérialisation calcule les valeurs des caractéristiques pour une fenêtre donnée et les stocke dans un magasin de matérialisation. Toutes les requêtes de caractéristiques peuvent ensuite utiliser ces valeurs depuis le magasin de matérialisation.

Sans matérialisation, une requête d’ensemble de fonctionnalités applique des transformations à la source à la volée et calcule les fonctionnalités avant de retourner les valeurs. Ce processus est bien adapté à la phase de prototypage. Toutefois, pour les opérations d’entraînement et d’inférence dans un environnement de production, la matérialisation des fonctionnalités offre une plus grande fiabilité et une plus grande disponibilité.

Le magasin Blob par défaut du magasin de caractéristiques est un conteneur Azure Data Lake Storage (ADLS). Un magasin de caractéristiques est toujours créé avec un magasin de matérialisation hors ligne et une identité managée assignée par l’utilisateur (UAI).

Si un magasin de fonctionnalités est créé avec des valeurs par défaut de paramètre offline_store=None et materialization_identity=None, alors le système effectue la configuration suivante :

1. Crée un conteneur ADLS en tant que magasin hors connexion.
2. Une UAI est créée et affectée au magasin de caractéristiques comme identité de matérialisation.
3. Attribue les autorisations RBAC (Role-Based Access Control) requises à l’UAI sur le magasin hors ligne.

Si vous le souhaitez, vous pouvez utiliser un conteneur ADLS existant comme magasin hors connexion en définissant le offline_store paramètre. Seuls les conteneurs ADLS sont pris en charge pour les magasins de matérialisation hors connexion.

Si vous le souhaitez, vous pouvez fournir une UAI existante en définissant un materialization_identity paramètre. Les autorisations RBAC requises sont attribuées à la UAI sur le magasin hors ligne lors de la création du magasin de caractéristiques.

L’exemple de code suivant montre la création d’un magasin de fonctionnalités avec des paramètres offline_store et materialization_identity définis par l'utilisateur.

   import os
   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   from azure.ai.ml.entities import (
      ManagedIdentityConfiguration,
      FeatureStore,
      MaterializationStore,
   )
   from azure.mgmt.msi import ManagedServiceIdentityClient

   # Get an existing offline store
   storage_subscription_id = "<OFFLINE_STORAGE_SUBSCRIPTION_ID>"
   storage_resource_group_name = "<OFFLINE_STORAGE_RESOURCE_GROUP>"
   storage_account_name = "<OFFLINE_STORAGE_ACCOUNT_NAME>"
   storage_file_system_name = "<OFFLINE_STORAGE_CONTAINER_NAME>"

   # Get ADLS container ARM ID
   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 = MaterializationStore(
      type="azure_data_lake_gen2",
      target=gen2_container_arm_id,
   )

   # Get an existing UAI
   uai_subscription_id = "<UAI_SUBSCRIPTION_ID>"
   uai_resource_group_name = "<UAI_RESOURCE_GROUP>"
   uai_name = "<FEATURE_STORE_UAI_NAME>"

   msi_client = ManagedServiceIdentityClient(
      AzureMLOnBehalfOfCredential(), uai_subscription_id
   )

   managed_identity = msi_client.user_assigned_identities.get(
      uai_resource_group_name, uai_name
   )

   # Get UAI information
   uai_principal_id = managed_identity.principal_id
   uai_client_id = managed_identity.client_id
   uai_arm_id = managed_identity.id

   materialization_identity1 = ManagedIdentityConfiguration(
      client_id=uai_client_id, principal_id=uai_principal_id, resource_id=uai_arm_id
   )

   # Create a feature store
   featurestore_name = "<FEATURE_STORE_NAME>"
   featurestore_location = "<AZURE_REGION>"
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

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

   # Use existing ADLS Gen2 container and UAI
   fs = FeatureStore(
      name=featurestore_name,
      location=featurestore_location,
      offline_store=offline_store,
      materialization_identity=materialization_identity1,
   )

   fs_poller = ml_client.feature_stores.begin_update(fs)

   print(fs_poller.result()) 

Après avoir activé la matérialisation sur le jeu de caractéristiques des transactions, vous pouvez effectuer un backfill. Vous pouvez également planifier des tâches de matérialisation récurrentes. Pour plus d’informations, consultez le troisième didacticiel de cette série, Activer la matérialisation récurrente et exécuter l’inférence par lots.

Définir spark.sql.shuffle.partitions dans le fichier YAML

La configuration Spark spark.sql.shuffle.partitions est un paramètre optionnel qui peut influencer le nombre de fichiers Parquet générés par jour lors de la matérialisation dans le magasin hors ligne. La valeur par défaut de ce paramètre est 200.

En guise de meilleure pratique, évitez la génération de nombreux petits fichiers Parquet. Si la récupération des caractéristiques hors ligne devient lente après la matérialisation, ouvrez le dossier correspondant dans le magasin hors ligne. Vérifiez si le problème implique trop de petits fichiers Parquet par jour et ajustez la valeur de ce paramètre en fonction de la taille des données de fonctionnalité.

transaction_asset_mat_yaml = (
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

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

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

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

Compléter les données pour l'ensemble de fonctionnalités des transactions

La matérialisation calcule les valeurs des fonctionnalités d'une fenêtre de fonctionnalité et stocke ces valeurs calculées dans un store de matérialisation. La matérialisation des caractéristiques améliore 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 backfill unique pour une fenêtre de 18 mois.

La cellule de code suivante matérialise les données par état None actuel ou Incomplete pour la fenêtre de fonctionnalité définie. Vous pouvez fournir une liste de plusieurs états de données, par exemple ["None", "Incomplete"], dans une seule tâche de remplissage.

feature_window_start_time = "2022-01-01T00:00.000Z"
feature_window_end_time = "2023-06-30T00:00.000Z"

!az ml feature-set backfill --name transactions --version 1 --by-data-status "['None', 'Incomplete']" --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

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

Afficher des données d’exemple issues du jeu de caractéristiques. 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() récupère les données d’apprentissage et d’inférence et utilise par défaut le stockage de matérialisation.

# 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 plus en détail la matérialisation hors ligne des caractéristiques

Vous pouvez explorer l’état de matérialisation des fonctions pour un ensemble de fonctions dans l’interface des travaux de matérialisation.

1. Ouvrez la page d’accueil globale d’Azure Machine Learning.

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

3. Dans la liste des 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 .

   

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

• Terminé (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 des données. Par exemple, l’instantané précédent comporte 16 intervalles de données dans le magasin de matérialisation hors ligne. 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 version d’ensemble de fonctionnalités.

Pendant le remplissage rétroactif, une nouvelle tâche de matérialisation est soumise pour chaque intervalle de données qui se trouve dans la fenêtre fonctionnelle définie. Aucun travail n’est envoyé si un travail de matérialisation est déjà en attente ou en cours d’exécution pour un intervalle de données qui n’est pas remblayé.

Vous pouvez relancer un job de matérialisation ayant échoué.

az ml feature-set backfill --by-job-id <JOB_ID_OF_FAILED_MATERIALIZATION_JOB> --name <FEATURE_SET_NAME> --version <VERSION>  --feature-store-name <FEATURE_STORE_NAME> --resource-group <RESOURCE_GROUP>

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

Mettre à jour un 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 une matérialisation hors connexion désactivée.

Si la matérialisation hors ligne est désactivée sur un jeu de caractéristiques, l’état de matérialisation des données déjà présentes dans le magasin hors ligne est réinitialisé. Cette réinitialisation rend les données déjà matérialisées inutilisables. Vous devez soumettre à nouveau les jobs de matérialisation après avoir réactivé la matérialisation hors ligne.

Nettoyage

Le cinquième tutoriel de cette série, Développer un ensemble de fonctionnalités avec une source personnalisée, explique comment supprimer les ressources.

Étape suivante

Ce tutoriel a permis de construire des données d’entraînement à partir du magasin de caractéristiques, d’activer la matérialisation vers le magasin hors ligne et d’effectuer un backfill.

Le tutoriel suivant de la série, Expérimenter et entraîner des modèles à l’aide de fonctionnalités vous montre comment exécuter l’entraînement de modèle à l’aide de ces fonctionnalités.

Contenu connexe

• Qu’est-ce qu’un magasin de fonctionnalités géré ?
• Comprendre les entités de niveau supérieur dans le magasin de fonctionnalités managé.
• Gérer le contrôle d’accès pour un magasin de fonctionnalités géré.
• Résoudre les problèmes de magasin de fonctionnalités géré.
• Schémas YAML CLI (v2)