Freigeben über

Tutorial 2: Experimentieren und Trainieren von Modellen mithilfe von Features

  • Artikel

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 zunächst eine Featuresatzspezifikation mit benutzerdefinierten Transformationen erstellen und anschließend den Featuresatz verwenden, um Trainingsdaten zu generieren, die Materialisierung zu aktivieren und einen Abgleich auszuführen. In diesem Tutorial wird gezeigt, wie Sie die Materialisierung aktivieren und einen Abgleich durchführen. Darüber hinaus wird gezeigt, wie Sie mit Features experimentieren, um die Modellleistung zu verbessern.

In diesem Tutorial lernen Sie Folgendes:

  • Sie erstellen einen Prototyp einer neuen Featuresatzspezifikation für accounts mit vorhandenen vorausberechneten Werten als Features. Anschließend registrieren Sie die lokale Featuresatzspezifikation als Featuresatz im Feature Store. Dieses Vorgehen unterscheidet sich vom ersten Tutorial, in dem Sie einen Featuresatz mit benutzerdefinierten Transformationen erstellt haben.
  • Wählen Sie Features für das Modell aus den Featuresätzen transactions und accounts aus, und speichern Sie sie als Spezifikation für den Featureabruf.
  • Führen Sie eine Trainingspipeline aus, die die Featureabrufspezifikation verwendet, um ein neues Modell zu trainieren. Diese Pipeline verwendet die integrierte Featureabrufkomponente, um die Trainingsdaten zu generieren.

Voraussetzungen

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

Einrichten

  1. Konfigurieren Sie das Spark-Notebook für Azure Machine Learning.

    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 and 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. Lassen Sie dieses Dokument geöffnet, und sehen Sie dort nach, um Links zur Dokumentation und weitere Erläuterungen zu erhalten.

    1. Wählen Sie im oberen Menü unter Serverlose Spark-Computeversion von Azure Machine Learning die Option Serverlose Spark-Computeversion in der Dropdownliste Compute 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-Pakete die Option Conda-Datei hochladen aus.
      3. Laden Sie die Datei conda.yml hoch, die Sie im ersten Tutorial hochgeladen haben.
      4. Optional: Erhöhen Sie das Sitzungstimeout (die Leerlaufzeit), 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.

    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.

    Stellen Sie sicher, dass Sie die Werte featurestore_name und featurestore_location aktualisieren, um widerzuspiegeln, was Sie im ersten Teil dieses Tutorials 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 Computecluster, wenn Sie die Trainings-/Batchrückschlussaufträ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 des Kontofeaturesatzes 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. Wenn Sie Funktionalitäten des verwalteten Feature Stores nutzen möchten, 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 mit Ihren 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. Exportieren Sie die Featuresatzspezifikation.

    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-Featuresatzspezifikation. Um die Spezifikation anzuzeigen, öffnen Sie die Datei featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml in dieser Dateistruktur.

    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 der Funktionsgruppe erforderlich sind.

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

    Als zusätzlicher Nutzen unterstützt die Persistenz 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 Features sollten Sie diese lokal testen und überprüfen, bevor Sie sie 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 wenn diese sinnvoll erscheinen, können Sie die Ressourcendefinition für einen Featuresatz beim 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 Featuresatz 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 den folgenden Schritten wählen Sie eine Liste der Features aus, führen eine Trainingspipeline aus und registrieren 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 globalen Angebotsseite von Azure Machine Learning.
    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 Featuresätze und Entitäten anzeigen. 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 verschiedenen registrierten und nicht registrierten Funktionsgruppen für lokale Experimente und Tests ausgewählt. Sie können jetzt in der Cloud experimentieren. Sie haben beim Modellversand mehr Flexibilität, wenn Sie die ausgewählten Features als Featureabrufspezifikation speichern und die Spezifikation dann im MLOps-Flow (Machine Learning Operations) oder CI/CD-Flow (Continuous Integration and Continuous Delivery) für Training und Rückschlüsse 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. Sie wird dann mit dem Modell verpackt.

      Die Rückschlussphase der Featureabruf verwendet, um die Features zu suchen. Sie integriert alle Phasen des Lebenszyklus des maschinellen Lernens. Änderungen an der Trainings-/Rückschlusspipeline können beim Experimentieren und Bereitstellen auf ein Minimum beschränkt bleiben.

      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 sein, wenn sie mit dem Modell paketiert ist. 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 diese basierend auf Änderungen der Featureabrufspezifikation 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 ihre Eingabe verwendet diese integrierte Komponente die Featureabrufspezifikation, die Beobachtungsdaten und den Spaltennamen des Zeitstempels. 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 Abgleichsauftrag 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 Schritt zur Modellregistrierung in der Trainingspipeline hat diesen Schritt ausgeführt. Sie haben die Featureabrufspezifikation während des Experimentierens erstellt. Jetzt wurde sie Teil der Modelldefinition. Im nächsten Tutorial erfahren Sie, wie es von Rückschlüssen 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 derselben Seite Modelle die Registerkarte Featuresätze aus. Auf dieser Registerkarte werden die Featuresätze transactions und accounts angezeigt, von denen dieses Modell abhängt.

  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 Featuresä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