Übung 4: Aktivieren der Online-Materialisierung und Ausführen der Online-Inferenz

Ein Azure Machine Learning verwalteter Featurespeicher hilft Ihnen, Features zu ermitteln, zu erstellen und zu operationalisieren. Features verbinden den Lebenszyklus des maschinellen Lernens ab der Prototypphase, in der Sie mit verschiedenen Features experimentieren. Der Lebenszyklus wird weiterhin in der Operationalisierungsphase ausgeführt, in der Sie Ihre Modelle bereitstellen, und die Ableitungsschritte suchen die Featuredaten. Weitere Informationen zum verwalteten Featurespeicher finden Sie unter Was ist verwalteter Featurespeicher?

Von Bedeutung

Azure Cache for Redis kündigte den Zeitplan zur Einstellung für alle SKUs an. Es wird empfohlen, Ihre vorhandenen Azure Cache for Redis Instanzen so schnell wie möglich in Azure verwaltete Redis zu verschieben.

Migrationsleitfaden:

• Migrieren Sie die Basic-, Standard- und Premium-Stufen nach Azure Managed Redis
• Migration der Enterprise-Ebene zu Azure Managed Redis

Weitere Informationen zur Einstellung finden Sie unter:

• Azure Cache for Redis Abkündigung: Was Sie wissen sollten und wie Sie sich vorbereiten
• Ablösung von Azure Cache for RedisFAQ

In Lernprogramm 1 wurde gezeigt, wie Sie eine Featuresatzspezifikation mit benutzerdefinierten Transformationen erstellen und dann diesen Featuresatz verwenden, um Schulungsdaten zu generieren, Materialisierung zu aktivieren und einen Rückfüllvorgang durchzuführen. In Lernprogramm 2 wurde gezeigt, wie Sie mit Features experimentieren, um die Modellleistung zu verbessern, und dann ein Modell trainieren und registrieren, das Features verwendet. In Lernprogramm 3 wurde gezeigt, wie Sie die wiederkehrende Materialisierung für den transactions Featuresatz aktivieren und eine Batch-Ableitungspipeline ausführen.

In diesem Tutorial haben Sie Folgendes durchgeführt:

• Einrichten eines Azure Cache for Redis
• Anfügen eines Cache an einen Feature Store als Onlinematerialisierungsspeicher und Erteilen der erforderlichen Berechtigungen
• Materialisieren eines Featuresatzes im Onlinespeicher
• Testen einer Onlinebereitstellung mit Modelldaten

Voraussetzungen

Hinweis

In diesem Lernprogramm wird ein Azure Machine Learning-Notizbuch mit Serverless Spark Compute verwendet.

• Achten Sie darauf, die Lernprogramme 1 bis 3 in dieser Reihe abzuschließen. Dieses Lernprogramm verwendet den Featurespeicher und andere Ressourcen, die Sie in diesen früheren Lernprogrammen erstellt haben.

Einrichten

In diesem Lernprogramm wird das Python Feature store Core SDK (azureml-featurestore) verwendet. Das Python SDK wird für Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge (CRUD) in Featurespeichern, Featuresätzen und Featurespeicherentitäten verwendet.

Sie müssen diese Ressourcen für dieses Tutorial nicht explizit installieren, da sie in den hier gezeigten Setupanweisungen durch die Datei online.yml abgedeckt werden.

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 featurestore_sample/notebooks/sdk_only/4.Enable-online-store-run-inference.ipynb öffnen und ausführen. Halten Sie dieses Tutorial geöffnet und nutzen Sie es für Dokumentationslinks und weitere Erläuterungen.

   1. Wählen Sie oben im Navigationsbereich im Dropdownmenü Compute die Option Serverloses Spark Compute aus.

   2. Konfigurieren der Sitzung:

      1. Laden Sie die Datei azureml-examples/sdk/python/featurestore-sample/project/env/online.yml auf Ihren lokalen Rechner herunter.
      2. Wählen Sie in configure session in der oberen Navigationsleiste Python pakete aus
      3. Wählen Sie Conda-Datei hochladen aus.
      4. Laden Sie die online.yml Datei von Ihrem lokalen Computer hoch, indem Sie dieselben Schritte ausführen, die im Hochladen der conda.yml Datei in Lernprogramm 1 beschrieben sind.
      5. Optional: Erhöhen Sie das Sitzungstimeout (Leerlaufzeit), um zu vermeiden, dass erforderliche Wiederholungen zu oft ausgeführt werden.

2. Diese Codezelle startet die Spark-Sitzung. Es dauert etwa 10 Minuten, um alle Abhängigkeiten zu installieren und die Spark-Sitzung zu starten.

   # Run this cell to start the spark session (any code block will start the session ). This can take approximately 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 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")

4. Initialisieren Sie MLClient für den Projektraum, in dem das Tutorial-Notebook läuft. MLClient wird für die Vorgänge Erstellen, Lesen, Aktualisieren und Löschen (CRUD) verwendet.

   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
   )

5. Initialisieren Sie MLClient für den Feature Store-Arbeitsbereich und für die CRUD-Vorgänge im Feature Store-Arbeitsbereich.

   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 MLClient
   fs_client = MLClient(
       AzureMLOnBehalfOfCredential(),
       featurestore_subscription_id,
       featurestore_resource_group_name,
       featurestore_name,
   )

   Hinweis

   Ein Feature Store-Arbeitsbereich unterstützt die projektübergreifende Wiederverwendung von Features. Ein Projektarbeitsbereich – der aktuell verwendete Arbeitsbereich – nutzt Features aus einem bestimmten Feature Store, um Modelle zu trainieren und Rückschlüsse dafür zu ziehen. Viele Projektarbeitsbereiche können denselben Feature Store-Arbeitsbereich gemeinsam nutzen und wiederverwenden.

6. Wie bereits erwähnt, verwendet dieses Lernprogramm das Python Feature store Core SDK (azureml-featurestore). Dieser initialisierte SDK-Client wird für CRUD-Vorgänge (Create, Read, Update, Delete; Erstellen, Lesen, Aktualisieren, Löschen) in Feature Stores, Featuresätzen und Feature Store-Entitäten verwendet.

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

Das Azure Cache for Redis vorbereiten

In diesem Tutorial wird Azure Cache for Redis als Onlinematerialisierungsspeicher verwendet. Sie können eine neue Redis-Instanz erstellen oder eine vorhandene Instanz wiederverwenden.

1. Legen Sie Werte für die Azure Cache for Redis Ressource fest, die als Online-Materialisierungsspeicher verwendet werden soll. Definieren Sie in dieser Codezelle den Namen der Azure Cache for Redis Ressource, die erstellt oder wiederverwendet werden soll. Sie können andere Standardeinstellungen außer Kraft setzen.

   ws_location = ws_client.workspaces.get(ws_client.workspace_name).location
   
   redis_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   redis_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
   redis_name = "<REDIS_NAME>"
   redis_location = ws_location

2. Sie können eine neue Redis-Instanz erstellen. Sie wählen die geeignete Redis Cache-Ebene (Basic, Standard, Premium oder Enterprise) aus. Wählen Sie eine SKU-Familie aus, die für die von Ihnen ausgewählte Cacheebene verfügbar ist. Weitere Informationen zu Ebenen und Cacheleistung finden Sie in dieser Ressource. Weitere Informationen zu SKU-Ebenen und Azure Cachefamilien finden Sie unter diese Ressource.

   Führen Sie diese Codezelle aus, um eine Azure Cache for Redis mit Premiumebene, SKU-Familie P und Cachekapazität 2 zu erstellen. Die Vorbereitung der Redis-Instanz kann zwischen 5 und 10 Minuten dauern.

   from azure.mgmt.redis import RedisManagementClient
   from azure.mgmt.redis.models import RedisCreateParameters, Sku, SkuFamily, SkuName
   
   management_client = RedisManagementClient(
       AzureMLOnBehalfOfCredential(), redis_subscription_id
   )
   
   # It usually takes about 5 - 10 min to finish the provision of the Redis instance.
   # If the following begin_create() call still hangs for longer than that,
   # please check the status of the Redis instance on the Azure portal and cancel the cell if the provision has completed.
   # This sample uses a PREMIUM tier Redis SKU from family P, which may cost more than a STANDARD tier SKU from family C.
   # Please choose the SKU tier and family according to your performance and pricing requirements.
   
   redis_arm_id = (
       management_client.redis.begin_create(
           resource_group_name=redis_resource_group_name,
           name=redis_name,
           parameters=RedisCreateParameters(
               location=redis_location,
               sku=Sku(name=SkuName.PREMIUM, family=SkuFamily.P, capacity=2),
           ),
       )
       .result()
       .id
   )
   
   print(redis_arm_id)

3. Optional verwendet diese Codezelle eine vorhandene Redis-Instanz mit dem zuvor definierten Namen wieder.

   redis_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Cache/Redis/{name}".format(
       sub_id=redis_subscription_id,
       rg=redis_resource_group_name,
       name=redis_name,
   )

Anfügen des Onlinematerialisierungsspeichers an den Feature Store

Der Feature Store benötigt die Azure Cache for Redis-Instanz als angefügte Ressource zur Verwendung als Onlinematerialisierungsspeicher. Die folgende Codezelle verarbeitet diesen Schritt:

from azure.ai.ml.entities import (
    ManagedIdentityConfiguration,
    FeatureStore,
    MaterializationStore,
)

online_store = MaterializationStore(type="redis", target=redis_arm_id)

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

fs = FeatureStore(
    name=featurestore_name,
    online_store=online_store,
)

fs_poller = ml_client.feature_stores.begin_create(fs)
print(fs_poller.result())

Hinweis

Während einer Feature-Store-Aktualisierung gewährt die Einstellung grant_materiaization_permissions=True allein nicht die erforderlichen RBAC-Berechtigungen für die UAI. Die Rollenzuweisungen an UAI erfolgen nur, wenn eine der folgenden Funktionen aktualisiert wird:

• Materialisierungsidentität
• Ziel für das Offline-Geschäft
• Ziel des Online-Shops

Ein Beispiel, das zeigt, wie Sie dies mit dem SDK tun können, finden Sie unter Tutorial: Verschiedene Ansätze für die Bereitstellung eines verwalteten FeaturespeichersRessource.

Materialisieren der Daten des accounts-Featuresatzes im Onlinespeicher

Materialisierung auf dem accounts-Feature-Set aktivieren

In einem früheren Teil dieser Tutorialreihe haben Sie das Funktionsset „Konten“ nicht materialisiert, da es über vorausberechnete Funktionen verfügte und nur in Batch-Inferenzszenarien verwendet wurde. Die folgende Codezelle ermöglicht die Onlinematerialisierung, sodass die Features im Onlinespeicher verfügbar werden und der Zugriff mit geringer Wartezeit verbunden ist. Zur Wahrung der Konsistenz wird auch die Offlinematerialisierung ermöglicht. Die Aktivierung der Offlinematerialisierung ist optional.

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

# Turn on both offline and online materialization on the "accounts" featureset.

accounts_fset_config = fs_client._featuresets.get(name="accounts", version="1")

accounts_fset_config.materialization_settings = MaterializationSettings(
    offline_enabled=True,
    online_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,
    },
    schedule=None,
)

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

Den account-Funktionssatz auffüllen

Die begin_backfill-Funktion füllt Daten in alle Materialisierungsspeicher aus, die für diesen Funktionssatz aktiviert sind. Hier sind Offline- und Onlinematerialisierung aktiviert. Diese Codezelle gleicht die Daten mit dem Online- und dem Offlinematerialisierungsspeicher ab.

from datetime import datetime, timedelta

# Trigger backfill on the "accounts" feature set.
# Backfill from 01/01/2020 to all the way to 3 hours ago.

st = datetime(2020, 1, 1, 0, 0, 0, 0)
et = datetime.now() - timedelta(hours=3)

poller = fs_client.feature_sets.begin_backfill(
    name="accounts",
    version="1",
    feature_window_start_time=st,
    feature_window_end_time=et,
    data_status=["None"],
)
print(poller.result().job_ids)

Tipp

• Die Granularität von feature_window_start_time und feature_window_end_time ist auf Sekunden begrenzt. Alle im Objekt datetime angegebenen Werte in Millisekunden werden ignoriert.
• Ein Materialisierungsauftrag wird nur dann übermittelt, wenn im Featurefenster Daten vorhanden sind, die den beim Übermitteln des Abgleichsauftrags definierten data_status entsprechen.

Diese Codezelle verfolgt den Abschluss der Backfill-Aufgabe. Bei der zuvor bereitgestellten Premium-Stufe des Azure Cache for Redis benötigt dieser Schritt möglicherweise ca. 10 Minuten.

# Get the job URL, and stream the job logs.
# With PREMIUM Redis SKU, SKU family "P", and cache capacity 2,
# it takes approximately 10 minutes to complete.
fs_client.jobs.stream(poller.result().job_ids[0])

Materialisieren der Daten des transactions-Featuresatzes im Onlinespeicher

Zuvor in dieser Tutorialreihe haben Sie die Daten des transactions-Featuresatzes im Offlinematerialisierungsspeicher materialisiert.

1. Diese Codezelle ermöglicht die Onlinematerialisierung des Feature-Sets transactions.

   # Enable materialization to online store for the "transactions" feature set.
   
   transactions_fset_config = fs_client._featuresets.get(name="transactions", version="1")
   transactions_fset_config.materialization_settings.online_enabled = True
   
   fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)
   print(fs_poller.result())

2. Diese Codezelle füllt die Daten sowohl im Speicher für Online- als auch Offline-Materialisierung nach, um sicherzustellen, dass beide Speicher die neuesten Daten enthalten. Der wiederkehrende Materialisierungsauftrag, den Sie in Übung 3 dieser Serie eingerichtet haben, materialisiert nun Daten sowohl in Online- als auch in Offline-Materialisierungsspeichern.

   # Trigger backfill on the "transactions" feature set to fill in the online/offline store.
   # Backfill from 01/01/2020 to all the way to 3 hours ago.
   
   from datetime import datetime, timedelta
   from azure.ai.ml.entities import DataAvailabilityStatus
   
   st = datetime(2020, 1, 1, 0, 0, 0, 0)
   et = datetime.now() - timedelta(hours=3)
   
   
   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)

   Diese Codezelle verfolgt den Abschluss der Backfill-Aufgabe. Bei Verwendung der zuvor bereitgestellten Premium-Stufe von Azure Cache für Redis kann dieser Schritt etwa fünf Minuten in Anspruch nehmen.

   # Get the job URL, and stream the job logs.
   # With PREMIUM Redis SKU, SKU family "P", and cache capacity 2,
   # it takes approximately 5 minutes to complete.
   fs_client.jobs.stream(poller.result().job_ids[0])

Weitere Untersuchung der Materialisierung von Online-Funktionen

Sie können den Feature-Materialisierungsstatus für ein Feature-Set über die Materialisierungsaufträge BENUTZEROBERFLÄCHE.

1. Öffnen Sie die Azure Machine Learning globale Zielseite

2. Wählen Sie Feature Stores im linken Fenster.

3. Wählen Sie aus der Liste der zugänglichen Feature Stores den Feature Store aus, für den Sie das Backfill durchgeführt haben.

4. Wählen Sie die Registerkarte Materialisierungsaufträge aus.

   

• Der Datenmaterialisierungsstatus kann sein
  • Vollständig (grün)
  • Unvollständig (rot)
  • Anhängig (blau)
  • Keiner (grau)
• Ein Datenintervall stellt einen zusammenhängenden Teil von Daten mit demselben Datenmaterialisierungsstatus dar. Der frühere Snapshot hat zum Beispiel 16 Datenintervalle im Offline-Materialisierungsspeicher.
• Ihre Daten können maximal 2.000 Datenintervalle haben. Wenn Ihre Daten mehr als 2.000 Datenintervalle enthalten, erstellen Sie eine neue Feature-Set-Version.
• Sie können eine Liste mit mehreren Datenstatus (z. B. ["None", "Incomplete"]) in einem einzigen Backfill-Auftrag angeben.
• Beim Backfill wird für jedes Datenintervall, das in das definierte Feature-Fenster fällt, ein neuer Materialisierungsauftrag eingereicht.
• Ein neuer Auftrag wird nicht für ein Datenintervall eingereicht, wenn bereits ein Materialisierungsauftrag aussteht oder wenn es für ein Datenintervall läuft, das noch nicht nachgefüllt wurde.

Aktualisierung des Online-Materialisierungsspeichers

• Um einen Onlinematerialisierungsspeicher auf der Ebene des Feature Stores zu aktualisieren, muss die Onlinematerialisierung für alle Featuresätze im Feature Store deaktiviert werden.
• Wenn die Onlinematerialisierung für einen Funktionsumfang deaktiviert ist, wird der Materialisierungsstatus der bereits materialisierten Daten im Onlinematerialisierungsspeicher zurückgesetzt. Dadurch werden die bereits materialisierten Daten unbrauchbar. Sie müssen Ihre Materialisierungsaufträge erneut übermitteln, nachdem Sie die Online-Materialisierung aktiviert haben.
• Wenn für einen Featuresatz zunächst nur die Offline-Materialisierung aktiviert wurde und später die Onlinematerialisierung aktiviert wird:
  • Der Standarddatenmaterialisierungsstatus der Daten im Online-Store ist None.
  • Wenn der erste Online-Materialisierungsauftrag übermittelt wird, werden die bereits im Offline-Speicher materialisierten Daten, sofern vorhanden, zur Berechnung der Online-Merkmale verwendet.
  • Wenn sich das Datenintervall für die Online-Materialisierung teilweise mit dem Datenintervall bereits materialisierter Daten im Offline-Speicher überschneidet, werden separate Materialisierungsaufträge für die sich überschneidenden und die sich nicht überschneidenden Teile des Datenintervalls eingereicht.

Lokales Testen

Verwenden Sie nun Ihre Entwicklungsumgebung, um nach Features im Onlinematerialisierungsspeicher zu suchen. Das Tutorial-Notebook, das an serverloses Spark Compute angefügt ist, dient als Entwicklungsumgebung.

Diese Codezelle analysiert die Liste der Features aus der vorhandenen Feature-Abruf Spezifikation.

# Parse the list of features from the existing feature retrieval specification.
feature_retrieval_spec_folder = root_dir + "/project/fraud_model/feature_retrieval_spec"

features = featurestore.resolve_feature_retrieval_spec(feature_retrieval_spec_folder)

features

Dieser Code ruft Featurewerte aus dem Online-Materialisierungsspeicher ab.

from azureml.featurestore import init_online_lookup
import time

# Initialize the online store client.
init_online_lookup(features, AzureMLOnBehalfOfCredential())

Bereiten Sie einige Beobachtungsdaten für Tests vor, und verwenden Sie diese Daten, um nach Features im Onlinematerialisierungsspeicher zu suchen. Während der Onlinesuche sind die in den Beobachtungsbeispieldaten definierten Schlüssel (accountID) möglicherweise nicht in Redis vorhanden (aufgrund von TTL). In diesem Fall:

1. Öffnen des Azure-Portals

2. Navigieren Sie zur Redis-Instanz.

3. Öffnen Sie die Konsole für die Redis-Instanz, und suchen Sie mit dem Befehl KEYS * nach vorhandenen Schlüsseln.

4. Ersetzen Sie die accountID-Werte in den Beobachtungsbeispieldaten durch die vorhandenen Schlüssel.

   import pyarrow
   from azureml.featurestore import get_online_features
   
   # Prepare test observation data
   obs = pyarrow.Table.from_pydict(
       {"accountID": ["A985156952816816", "A1055521248929430", "A914800935560176"]}
   )
   
   # Online lookup:
   # It may happen that the keys defined in the observation sample data above does not exist in the Redis (due to TTL).
   # If this happens, go to Azure portal and navigate to the Redis instance, open its console and check for existing keys using command "KEYS *"
   # and replace the sample observation data with the existing keys.
   df = get_online_features(features, obs)
   df

Mit diesen Schritten wurden Features im Onlinespeicher gesucht. Im nächsten Schritt testen Sie Onlinefeatures mit einem Azure Machine Learning verwalteten Onlineendpunkt.

Testen von Online-Funktionen am verwalteten Online-Endpunkt von Azure Machine Learning

Ein verwalteter Onlineendpunkt stellt Modelle für Online-/Echtzeitrückschlüsse bereit und bewertet diese. Sie können jede verfügbare Rückschlusstechnologie verwenden, z. B. Kubernetes.

Dieser Schritt umfasst die folgenden Aktionen:

1. Erstellen Sie einen Azure Machine Learning verwalteten Onlineendpunkt.
2. Zuweisen der erforderlichen RBAC-Berechtigungen (Role-Based Access Control, rollenbasierte Zugriffssteuerung)
3. Stellen Sie das Modell bereit, das Sie in Tutorial 3 der Tutorialreihe trainiert haben. Das in diesem Schritt verwendete Bewertungsskript enthält den Code zum Suchen von Onlinefeatures.
4. Bewerten des Modells mit Beispieldaten

Erstellen Sie einen verwalteten Azure Machine Learning-Onlineendpunkt.

Weitere Informationen zu verwalteten Onlineendpunkten finden Sie in dieser Ressource. Mit der API für den verwalteten Feature Store können Sie auch Onlinefeatures von anderen Rückschlussplattformen nachschlagen.

Diese Codezelle definiert den verwalteten Onlineendpunkt fraud-model:

from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    ManagedOnlineEndpoint,
    Model,
    CodeConfiguration,
    Environment,
)


endpoint_name = "<ENDPOINT_NAME>"

endpoint = ManagedOnlineEndpoint(name=endpoint_name, auth_mode="key")

Diese Codezelle erstellt den verwalteten Onlineendpunkt, der in der vorherigen Codezelle definiert wurde:

ws_client.online_endpoints.begin_create_or_update(endpoint).result()

Gewähren der erforderlichen RBAC-Berechtigungen

Hier erteilen Sie dem verwalteten Onlineendpunkt in der Redis-Instanz und im Feature Store die erforderlichen RBAC-Berechtigungen. Der Bewertungscode in der Modellbereitstellung benötigt diese RBAC-Berechtigungen, um mit der verwalteten Feature-Store-API erfolgreich nach Features im Online-Store zu suchen.

Abrufen der verwalteten Identität des verwalteten Onlineendpunkts

Diese Codezelle ruft die verwaltete Identität des verwalteten Onlineendpunkts ab:

# Get managed identity of the managed online endpoint.
endpoint = ws_client.online_endpoints.get(endpoint_name)

model_endpoint_msi_principal_id = endpoint.identity.principal_id
model_endpoint_msi_principal_id

Zuweisen der Rolle Contributor für die verwaltete Identität des Onlineendpunkts in Azure Cache for Redis

Die folgende Codezelle weist der verwalteten Identität des Onlineendpunkts in der Redis-Instanz die Rolle Contributor zu. Diese RBAC-Berechtigung ist erforderlich, um Daten im Redis-Onlinespeicher zu materialisieren.

from azure.core.exceptions import ResourceExistsError
from azure.mgmt.msi import ManagedServiceIdentityClient
from azure.mgmt.msi.models import Identity
from azure.mgmt.authorization import AuthorizationManagementClient
from azure.mgmt.authorization.models import RoleAssignmentCreateParameters
from uuid import uuid4

auth_client = AuthorizationManagementClient(
    AzureMLOnBehalfOfCredential(), redis_subscription_id
)

scope = f"/subscriptions/{redis_subscription_id}/resourceGroups/{redis_resource_group_name}/providers/Microsoft.Cache/Redis/{redis_name}"


# The role definition ID for the "contributor" role on the redis cache
# You can find other built-in role definition IDs in the Azure documentation
role_definition_id = f"/subscriptions/{redis_subscription_id}/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c"

# Generate a random UUID for the role assignment name
role_assignment_name = str(uuid4())

# Set up the role assignment creation parameters
role_assignment_params = RoleAssignmentCreateParameters(
    principal_id=model_endpoint_msi_principal_id,
    role_definition_id=role_definition_id,
    principal_type="ServicePrincipal",
)

# Create the role assignment
try:
    # Create the role assignment
    result = auth_client.role_assignments.create(
        scope, role_assignment_name, role_assignment_params
    )
    print(
        f"Redis RBAC granted to managed identity '{model_endpoint_msi_principal_id}'."
    )
except ResourceExistsError:
    print(
        f"Redis RBAC already exists for managed identity '{model_endpoint_msi_principal_id}'."
    )

Zuweisen der Rolle AzureML Wissenschaftliche Fachkraft für Daten für die verwaltete Identität des Onlineendpunkts im Feature Store

Die folgende Codezelle weist der verwalteten Identität des Onlineendpunkts im Feature Store die Rolle AzureML Wissenschaftliche Fachkraft für Daten zu. Diese RBAC-Berechtigung ist für eine erfolgreiche Bereitstellung des Modells für den Onlineendpunkt erforderlich.

auth_client = AuthorizationManagementClient(
    AzureMLOnBehalfOfCredential(), featurestore_subscription_id
)

scope = f"/subscriptions/{featurestore_subscription_id}/resourceGroups/{featurestore_resource_group_name}/providers/Microsoft.MachineLearningServices/workspaces/{featurestore_name}"

# The role definition ID for the "AzureML Data Scientist" role.
# You can find other built-in role definition IDs in the Azure documentation.
role_definition_id = f"/subscriptions/{featurestore_subscription_id}/providers/Microsoft.Authorization/roleDefinitions/f6c7c914-8db3-469d-8ca1-694a8f32e121"

# Generate a random UUID for the role assignment name.
role_assignment_name = str(uuid4())

# Set up the role assignment creation parameters.
role_assignment_params = RoleAssignmentCreateParameters(
    principal_id=model_endpoint_msi_principal_id,
    role_definition_id=role_definition_id,
    principal_type="ServicePrincipal",
)

# Create the role assignment
try:
    # Create the role assignment
    result = auth_client.role_assignments.create(
        scope, role_assignment_name, role_assignment_params
    )
    print(
        f"Feature store RBAC granted to managed identity '{model_endpoint_msi_principal_id}'."
    )
except ResourceExistsError:
    print(
        f"Feature store RBAC already exists for managed identity '{model_endpoint_msi_principal_id}'."
    )

Bereitstellen des Modells für den Online-Endpunkt

Sehen Sie sich das Bewertungsskript project/fraud_model/online_inference/src/scoring.py an. Das Bewertungsskript

1. Laden der Featuremetadaten aus der Featureabrufspezifikation, die mit dem Modell während des Modelltrainings gepackt wird. Diese Aufgabe wird in Tutorial 3 dieser Tutorialreihe behandelt. Die Spezifikation enthält Features aus den Featuresätzen transactions und accounts.
2. Suchen der Onlinefeatures mithilfe der Indexschlüssel aus der Anforderung, wenn eine Eingaberückschlussanforderung empfangen wird. In diesem Fall ist die Indexspalte für beide Featuresätze accountID.
3. Übergeben der Features an das Modell, um den Rückschluss auszuführen, und Zurückgeben der Antwort. Die Antwort ist ein boolescher Wert, der die Variable is_fraud darstellt.

Führen Sie als Nächstes die folgende Codezelle aus, um eine Definition für die verwaltete Onlinebereitstellungsdefinition für die Modellbereitstellung zu erstellen.

deployment = ManagedOnlineDeployment(
    name="green",
    endpoint_name=endpoint_name,
    model="azureml:fraud_model:1",
    code_configuration=CodeConfiguration(
        code=root_dir + "/project/fraud_model/online_inference/src/",
        scoring_script="scoring.py",
    ),
    environment=Environment(
        conda_file=root_dir + "/project/fraud_model/online_inference/conda.yml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

Stellen Sie das Modell mit der folgenden Codezelle für den Onlineendpunkt bereit. Der Einsatz kann vier bis fünf Minuten dauern.

# Model deployment to online enpoint may take 4-5 minutes.
ws_client.online_deployments.begin_create_or_update(deployment).result()

Testen der Onlinebereitstellung mit Modelldaten

Führen Sie die folgende Codezelle aus, um die Onlinebereitstellung mit den Modelldaten zu testen. Die Zelle sollte 0 oder 1 als Ausgabe anzeigen.

# Test the online deployment using the mock data.
sample_data = root_dir + "/project/fraud_model/online_inference/test.json"
ws_client.online_endpoints.invoke(
    endpoint_name=endpoint_name, request_file=sample_data, deployment_name="green"
)

Bereinigung

Lernprogramm 5: Entwickeln eines Featuresatzes mit einer benutzerdefinierten Quelle beschreibt, wie die Ressourcen gelöscht werden.

Nächste Schritte

• Lernprogramm 6: Netzwerkisolation für den Featurespeicher
• Azure Machine Learning Feature speichert Beispiel-Repository