Tutorial 2: Experimentieren und Trainieren von Modellen mithilfe von Features

In dieser Tutorialreihe erfahren Sie, wie Features nahtlos alle Phasen des Lebenszyklus für maschinelles Lernen integrieren: Prototyperstellung, Training und Operationalisierung.

Im ersten Tutorial wurde gezeigt, wie Sie eine Featuresatzspezifikation mit benutzerdefinierten Transformationen erstellen. Anschließend wurde beschrieben, wie Sie den Featuresatz verwenden, um Trainingsdaten zu generieren, die Materialisierung zu aktivieren und einen Backfill auszuführen. In diesem Tutorial wird gezeigt, wie Sie die Materialisierung aktivieren und ein Auffüllen durchführen. Darüber hinaus wird gezeigt, wie Sie mit Features experimentieren, um die Modellleistung zu verbessern.

In diesem Tutorial lernen Sie Folgendes:

Voraussetzungen

Bevor Sie mit diesem Tutorial fortfahren, sollten Sie unbedingt das erste Tutorial der Reihe abschließen.

Einrichten

1. Konfigurieren Sie das Azure Machine Learning Spark-Notizbuch.

   Sie können ein neues Notebook erstellen und die Anweisungen in diesem Tutorial Schritt für Schritt ausführen. Sie können auch das vorhandene Notebook mit dem Namen 2.Experiment-train-models-using-features.ipynb aus dem Verzeichnis featurestore_sample/notebooks öffnen und ausführen. Sie können sdk_only oder sdk_and_cli auswählen. Halten Sie dieses Tutorial geöffnet und nutzen Sie es für Dokumentationslinks und weitere Erläuterungen.

   1. Wählen Sie im oberen Menü in der Dropdownliste ComputeServerless Spark Compute unter Azure Machine Learning Serverless Spark aus.

   2. Konfigurieren der Sitzung:

      1. Wenn auf der Symbolleiste Sitzung konfigurieren angezeigt wird, wählen Sie diese Option aus.
      2. Wählen Sie auf der Registerkarte Python paketeUpload Conda-Datei aus.
      3. Laden Sie die Datei conda.yml hoch, die Sie im ersten Tutorial hochgeladen haben.
      4. Optional können Sie das Sitzungstimeout (Leerlaufzeit) erhöhen, um häufige Wiederholungen der Überprüfung von Voraussetzungen zu vermeiden.

2. Starten Sie die Spark-Sitzung.

   # 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. Richten Sie das Stammverzeichnis für die Beispiele ein.

   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. Richten Sie die CLI ein.

   • Python SDK
   • Azure CLI

   Nicht zutreffend.

1. Initialisieren Sie die Variablen für den Projektarbeitsbereich.

   Dies ist der aktuelle Arbeitsbereich, und das Tutorial-Notebook wird in dieser Ressource ausgeführt.

   ### 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. Initialisieren Sie die Variablen für den Feature Store.

   Aktualisieren Sie die Werte featurestore_name und featurestore_location, sodass sie dem entsprechen, was Sie im ersten Tutorial erstellt haben.

   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. Initialisieren Sie den Verbrauchs-Client für den Feature Store.

   # 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. Erstellen Sie im Projektarbeitsbereich einen Computecluster namens cpu-cluster.

   Sie benötigen diesen Rechencluster, wenn Sie die Trainings-/Batch-Inferenzaufträge ausführen.

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

Erstellen Sie den Funktionssatz für Konten in einer lokalen Umgebung.

Im ersten Tutorial haben Sie einen transactions-Featuresatz mit benutzerdefinierten Transformationen erstellt. Hier erstellen Sie einen accounts-Featuresatz, der vorausberechnete Werte verwendet.

Zum Onboarding vorausberechneter Features können Sie eine Featuresatzspezifikation erstellen, ohne Transformationscode zu schreiben. Sie verwenden eine Funktionssatzspezifikation zum Entwickeln und Testen eines Featuresatzes in einer vollständig lokalen Entwicklungsumgebung.

Sie müssen keine Verbindung mit einem Feature Store herstellen. In diesem Verfahren erstellen Sie die Featuresatzspezifikation lokal und erstellen dann eine Stichprobe der Werte daraus. Um die Funktionen des verwalteten Feature Stores nutzen zu können, müssen Sie eine Featureressourcendefinition verwenden, um die Featuresatzspezifikation bei einem Feature Store zu registrieren. Die späteren Schritte in diesem Tutorial enthalten weitere Details.

1. Untersuchen Sie die Quelldaten für die Konten.

   Hinweis

   Dieses Notebook verwendet Beispieldaten, die in einem öffentlich zugänglichen Blobcontainer gehostet werden. Nur ein wasbs-Treiber kann sie in Spark lesen. Wenn Sie Featuresätze mithilfe ihrer eigenen Quelldaten erstellen, hosten Sie diese Featuresätze in einem Azure Data Lake Storage Gen2 Konto, und verwenden Sie einen abfss Treiber im Datenpfad.

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

2. Erstellen Sie die accounts-Funktionssatzspezifikation lokal aus diesen vorausberechneten Features.

   Sie benötigen hier keinen Transformationscode, da Sie auf vorberechnete Features verweisen.

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

3. Als Funktionssatzspezifikation exportieren.

   Um die Featuresatzspezifikation beim Feature Store zu registrieren, müssen Sie die Featuresatzspezifikation in einem bestimmten Format speichern.

   Nachdem Sie die nächste Zelle ausgeführt haben, überprüfen Sie die generierte accounts-Feature-Set-Spezifikation. Um die Spezifikation anzuzeigen, öffnen Sie die Datei featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml im Dateibaum.

   Die Spezifikation verfügt über diese wichtigen Elemente:

   • source: ein Verweis auf eine Speicherressource. In diesem Fall handelt es sich um eine Parquet-Datei in einer Blob Storage-Ressource.

   • features: eine Liste der Features und ihrer Datentypen. Mit dem bereitgestellten Transformationscode muss der Code einen Datenrahmen zurückgeben, der den Features und Datentypen entspricht. Ohne den bereitgestellten Transformationscode erstellt das System die Abfrage, um die Features und Datentypen der Quelle zuzuordnen. In diesem Fall enthält die generierte accounts-Featuresatzspezifikation keinen Transformationscode, da Features vorausberechnet sind.

   • index_columns: die Joinschlüssel, die für den Zugriff auf Werte aus dem Funktionssatz erforderlich sind.

   Weitere Informationen finden Sie unter Grundlegendes zu Entitäten auf oberster Ebene im verwalteten Feature Store und YAML-Schema für die Featuresatzspezifikation der CLI (v2).

   Als einen zusätzlichen Vorteil unterstützt die Datenpersistenz die Versionskontrolle.

   Sie benötigen hier keinen Transformationscode, da Sie auf vorberechnete Features verweisen.

   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)

Lokales Experimentieren mit nicht registrierten Features und Registrieren beim Feature Store, wenn Sie bereit sind

Bei der Entwicklung von Funktionen sollten Sie diese lokal testen und überprüfen, bevor Sie diese beim Feature Store registrieren oder Trainingspipelines in der Cloud ausführen. Eine Kombination aus einem lokalen, nicht registrierten Featuresatz (accounts) und einem im Feature Store registrierten Featuresatz (transactions) generiert Trainingsdaten für das Machine Learning-Modell.

1. Wählen Sie Features für das Modell aus.

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

2. Generieren Sie lokal Trainingsdaten.

   In diesem Schritt werden zur Veranschaulichung Trainingsdaten generiert. Optional können Sie Modelle hier lokal trainieren. Spätere Schritten in diesem Tutorial erläutern, wie Sie ein Modell in der Cloud trainieren.

   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

3. Registrieren Sie den accounts-Featuresatz beim Feature Store.

   Nachdem Sie lokal mit Featuredefinitionen experimentiert haben und diese Ihnen sinnvoll erscheinen, können Sie eine Featuresatz-Ressourcendefinition im Feature Store registrieren.

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

4. Rufen Sie den registrierten Featureset ab und testen Sie ihn.

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

Ausführen eines Trainingsexperiments

In diesen Schritten wählen Sie eine Liste von Features aus, führen Sie eine Trainingspipeline aus, und registrieren Sie das Modell. Sie können diese Schritte wiederholen, bis das Modell wie gewünscht funktioniert.

1. Optional können Sie Features über die Feature Store-Benutzeroberfläche ermitteln.

   Dieser Schritt wurde im ersten Tutorial behandelt, als Sie den transactions-Featuresatz registriert haben. Da Sie auch über einen accounts- Featuresatz verfügen, können Sie die verfügbaren Features durchsuchen:

   1. Wechseln Sie zur Azure Machine Learning globalen Zielseite.
   2. Wählen Sie im linken Bereich Feature Stores aus.
   3. Wählen Sie in der Liste der Feature Stores den Feature Store aus, den Sie zuvor erstellt haben.

   Auf der Benutzeroberfläche werden die von Ihnen erstellten Funktionssätze und Entitäten angezeigt. Wählen Sie Featuresätze aus, um die Featuredefinitionen zu durchsuchen. Sie können auch das Feld für die globale Suche verwenden, um in Feature Stores nach Funktionssätzen zu suchen.

2. Optional können Sie Features über das SDK ermitteln.

   # 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

3. Wählen Sie Features für das Modell aus, und exportieren Sie diese als Featureabrufspezifikation.

   In den vorherigen Schritten haben Sie Features aus einer Kombination von registrierten und nicht registrierten Featuresätzen für lokale Experimente und Tests ausgewählt. Sie können jetzt in der Cloud experimentieren. Ihre Modellversand-Agilität erhöht sich, wenn Sie die ausgewählten Features als Feature-Abrufspezifikation speichern und diese Spezifikation dann im MLOps-Flow (Machine Learning Operations) oder CI/CD-Flow (Continuous Integration and Continuous Delivery) für das Training und die Inferenz verwenden.

   1. Wählen Sie Features für das Modell aus.

      # 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. Exportieren Sie die ausgewählten Features als Featureabrufspezifikation.

      Eine Featureabrufspezifikation ist eine portierbare Definition der einem Modell zugeordneten Featureliste. Sie kann dazu beitragen, die Entwicklung und den Betrieb eines Machine Learning-Modells zu optimieren. Sie wird zu einer Eingabe für die Trainingspipeline, die die Trainingsdaten generiert. Dann wird es mit dem Modell verpackt.

      Die Inferenzphase verwendet den Featureabruf, um die Features abzurufen. Sie integriert alle Phasen des Lebenszyklus des maschinellen Lernens. Änderungen an der Trainings-/Inferenzpipeline können beim Experimentieren und Implementieren auf ein Minimum reduziert werden.

      Die Verwendung der Featureabrufspezifikation und der integrierten Featureabrufkomponente ist optional. Sie können die API get_offline_features() direkt verwenden, wie zuvor gezeigt. Der Name der Spezifikation sollte feature_retrieval_spec.yaml lauten, wenn Sie sie mit dem Modell packen. Auf diese Weise kann das System sie erkennen.

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

Trainieren in der Cloud mit Pipelines und Registrieren des Modells

In diesem Verfahren lösen Sie die Trainingspipeline manuell aus. In einem Produktionsszenario könnte eine CI/CD-Pipeline es basierend auf Änderungen an der Spezifikation für den Feature-Abruf im Quellrepository auslösen. Sie können das Modell registrieren, wenn es zufriedenstellend ist.

1. Führen Sie die Trainingspipeline aus.

   Die Trainingspipeline umfasst die folgenden Schritte:

   1. Featureabruf: Für die Eingabe verwendet diese integrierte Komponente die Featureabrufspezifikation, die Beobachtungsdaten und den Spaltennamen time-stamp. Anschließend werden die Trainingsdaten als Ausgabe generiert. Diese Schritte werden als verwalteter Spark-Auftrag ausgeführt.

   2. Training: Basierend auf den Trainingsdaten trainiert dieser Schritt das Modell und generiert dann ein Modell (noch nicht registriert).

   3. Auswertung: Dieser Schritt überprüft, ob die Modellleistung innerhalb eines Schwellenwerts liegt. (In diesem Tutorial handelt es sich um einen Platzhalterschritt zur Veranschaulichung.)

   4. Registrieren des Modells: Dieser Schritt registriert das Modell.

      Hinweis

      Im zweiten Tutorial haben Sie einen Backfill-Job ausgeführt, um Daten für einen transactions-Featuresatz zu materialisieren. Der Schritt für den Funktionsabruf liest Funktionswerte aus einem Offlinespeicher für diesen Funktionssatz. Das Verhalten ist dasselbe, auch wenn Sie die get_offline_features()-API verwenden.

      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. Untersuchen Sie die Trainingspipeline und das Modell.

      • Um die Pipelineschritte anzuzeigen, wählen Sie den Link für die Webansicht-Pipeline aus, und öffnen Sie ihn in einem neuen Fenster.

2. Verwenden Sie die Featureabrufspezifikation in den Modellartefakten:

   1. Wählen Sie im linken Bereich des aktuellen Arbeitsbereichs Modelle mit der rechten Maustaste aus.
   2. Wählen Auf einer neuen Registerkarte oder in einem neuen Fenster öffnen aus.
   3. Wählen Sie fraud_model aus.
   4. Wählen Sie Artefakte.

   Die Featureabrufspezifikation wird zusammen mit dem Modell paketiert. Der Prozess der Modellregistrierung in der Trainingspipeline hat diese Aufgabe übernommen. Sie haben die Featureabrufspezifikation während des Experimentierens erstellt. Jetzt wurde sie Teil der Modelldefinition. Im nächsten Tutorial erfahren Sie, wie sie beim Rückschlussprozess verwendet wird.

Anzeigen des Funktionssatzes und der Modellabhängigkeiten

1. Zeigen Sie die Liste der Featuresätze an, die dem Modell zugeordnet sind.

   Wählen Sie auf der Seite Modelle die Registerkarte Featuresätze aus. Auf dieser Registerkarte werden die Featuresätze transactions und accounts angezeigt. Dieses Modell ist von diesen Featuresätzen abhängig.

2. Zeigen Sie die Liste mit Modellen an, die die Featuresätze verwenden:

   1. Öffnen Sie die Feature Store-Benutzeroberfläche (früher in diesem Tutorial beschrieben).
   2. Wählen Sie im linken Bereich Funktionssätze aus.
   3. Wählen Sie einen Featuresatz aus.
   4. Wählen Sie die Registerkarte Modelle aus.

   Diese Liste wurde durch die Featureabrufspezifikation festgelegt, als das Modell registriert wurde.

Bereinigen

Das fünfte Tutorial der Reihe beschreibt, wie Sie die Ressourcen löschen.

Nächste Schritte

• Fahren Sie mit dem nächsten Tutorial in der Reihe fort: Aktivieren Sie die wiederkehrende Materialisierung und führen Sie die Stapel-Inferenz aus.
• Erfahren Sie mehr über Feature-Store-Konzepte und Top-Level-Entitäten im verwalteten Feature Store.
• Erfahren Sie mehr über die Identitäts- und Zugriffssteuerung für verwaltete Feature Stores.
• Sehen Sie sich den Leitfaden zur Problembehandlung für verwaltete Feature Stores an.
• Lesen Sie die YAML-Referenz.