Progressiver Rollout von MLflow-Modellen für Onlineendpunkte

Artikel
09/03/2024

In diesem Artikel erfahren Sie, wie MLflow-Modelle schrittweise aktualisiert und auf Onlineendpunkten bereitgestellt werden können, ohne eine Dienstunterbrechung zu verursachen. Sie verwenden die Blau-Grün-Bereitstellung, auch bekannt als sichere Rolloutstrategie, um eine neue Version eines Webdiensts in die Produktion einzuführen. Mit dieser Strategie können Sie Ihre neue Version des Webdiensts für eine kleine Teilmenge von Benutzern oder Anforderungen bereitstellen, bevor Sie sie vollständig einführen.

Über dieses Beispiel

Onlineendpunkte verfügen über ein Konzept aus Endpunkt und Bereitstellung. Ein Endpunkt stellt die API dar, die Kunden zur Nutzung des Modells verwenden, während die Bereitstellung die spezifische Implementierung dieser API angibt. Diese Unterscheidung ermöglicht es Benutzern, die API von der Implementierung zu entkoppeln und die zugrunde liegende Implementierung zu ändern, ohne den Consumer zu beeinträchtigen. In diesem Beispiel werden solche Konzepte verwendet, um das bereitgestellte Modell ohne Dienstunterbrechung auf Endpunkten zu aktualisieren.

Das Modell, das wir bereitstellen werden, basiert auf dem UCI Heart Disease Data Set. Die Datenbank enthält 76 Attribute, von denen wir eine Teilmenge von 14 verwenden. Das Modell versucht, das Vorhandensein einer Herzerkrankung bei einem Patienten vorherzusagen. Der Wert ist eine ganze Zahl, entweder 0 (nicht vorhanden) oder 1 (vorhanden). Es wurde mit einem XGBBoost-Klassifizierer trainiert, und alle erforderlichen Vorverarbeitungen wurden in einer scikit-learn-Pipeline zusammengefasst. Somit handelt es sich bei diesem Modell um eine End-to-End-Pipeline von den Rohdaten bis zu den Vorhersagen.

Die Informationen in diesem Artikel basieren auf Codebeispielen, die im Repository azureml-examples enthalten sind. Klonen Sie das Repository, und wechseln Sie dann in das Verzeichnis sdk/using-mlflow/deploy, um die Befehle lokal auszuführen, ohne Dateien kopieren/einfügen zu müssen.

Folgen in Jupyter Notebooks

Sie können diesem Beispiel in den folgenden Notebooks folgen. Öffnen Sie im geklonten Repository folgendes Notebook: mlflow_sdk_online_endpoints_progresive.ipynb.

Voraussetzungen

Stellen Sie vor dem Ausführen der Schritte in diesem Artikel sicher, dass Sie über die folgenden erforderlichen Komponenten verfügen:

Ein Azure-Abonnement. Wenn Sie nicht über ein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen. Probieren Sie die kostenlose oder kostenpflichtige Version von Azure Machine Learning aus.
Die rollenbasierte Zugriffssteuerung in Azure (Azure RBAC) wird verwendet, um Zugriff auf Vorgänge in Azure Machine Learning zu gewähren. Um die Schritte in diesem Artikel auszuführen, muss Ihrem Benutzerkonto die Rolle „Besitzer“ oder „Mitwirkender“ für den Azure Machine Learning-Arbeitsbereich bzw. eine benutzerdefinierte Rolle zugewiesen werden, die „Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*“ zulässt. Weitere Informationen finden Sie unter Zugriff auf einen Azure Machine Learning-Arbeitsbereich verwalten.

Darüber hinaus müssen Sie Folgendes durchführen:

Installieren Sie die Azure CLI und die ml-Erweiterung für die Azure CLI. Weitere Informationen finden Sie unter Installieren, Einrichten und Verwenden der CLI (v2).

Installieren Sie das MLflow SDK-Paket mlflow und das Azure Machine Learning-Plug-In für MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
Wenn Sie nicht in der Azure ML-Compute-Umgebung arbeiten, konfigurieren Sie den MLflow-Nachverfolgungs-URI oder den URI der MLflow-Registrierung so, dass er auf den Arbeitsbereich verweist, in dem Sie arbeiten. Das Konfigurieren von MLflow für Azure Machine Learning lernen.

Herstellen einer Verbindung mit Ihrem Arbeitsbereich

Zunächst stellen wir eine Verbindung mit dem Azure Machine Learning-Arbeitsbereich her, an dem wir arbeiten werden.

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Der Arbeitsbereich ist die Ressource der obersten Ebene für Azure Machine Learning und ein zentraler Ort für die Arbeit mit allen Artefakten, die Sie während der Nutzung von Azure Machine Learning erstellen. In diesem Abschnitt stellen wir eine Verbindung mit dem Arbeitsbereich her, in dem Sie die Bereitstellung vornehmen werden.

Importieren Sie die erforderlichen Bibliotheken.

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import ManagedOnlineEndpoint, ManagedOnlineDeployment, Model
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

Konfigurieren von Arbeitsbereichsdetails und Abrufen eines Handles für den Arbeitsbereich:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Importieren der erforderlichen Bibliotheken

import json
import mlflow
import requests
import pandas as pd
from mlflow.deployments import get_deploy_client

Konfigurieren Sie den MLflow-Client und den Bereitstellungsclient:

mlflow_client = mlflow.MLflowClient()
deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Registrieren des Modells in der Registrierung

Stellen Sie sicher, dass Ihr Modell in der Azure Machine Learning-Registrierung registriert ist. Die Bereitstellung nicht registrierter Modelle wird in Azure Machine Learning nicht unterstützt. Sie können ein neues Modell mit dem MLflow-SDK registrieren:

MODEL_NAME='heart-classifier'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "model"

model_name = 'heart-classifier'
model_local_path = "model"

model = ml_client.models.create_or_update(
     Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'heart-classifier'
model_local_path = "model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Erstellen eines Onlineendpunkts

Onlineendpunkte sind Endpunkte, die für Onlinerückschlüsse (Echtzeit) verwendet werden. Onlineendpunkte enthalten Bereitstellungen, die bereit sind, Daten von Clients zu empfangen und Antworten in Echtzeit zurückzusenden.

Wir werden diese Funktionalität nutzen, indem wir mehrere Versionen desselben Modells unter demselben Endpunkt bereitstellen. Die neue Bereitstellung empfängt zu Beginn jedoch 0 % des Datenverkehrs. Sobald wir sicher sind, dass das neue Modell ordnungsgemäß funktioniert, werden wir den Datenverkehr schrittweise von einer Bereitstellung zur anderen verschieben.

Endpunkte erfordern einen Namen, der in derselben Region eindeutig sein muss. Erstellen Sie daher einen Namen, der noch nicht vorhanden ist:

ENDPOINT_SUFIX=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w ${1:-5} | head -n 1)
ENDPOINT_NAME="heart-classifier-$ENDPOINT_SUFIX"

import random
import string

# Creating a unique endpoint name by including a random suffix
allowed_chars = string.ascii_lowercase + string.digits
endpoint_suffix = "".join(random.choice(allowed_chars) for x in range(5))
endpoint_name = "heart-classifier-" + endpoint_suffix

print(f"Endpoint name: {endpoint_name}")

import random
import string

# Creating a unique endpoint name by including a random suffix
allowed_chars = string.ascii_lowercase + string.digits
endpoint_suffix = "".join(random.choice(allowed_chars) for x in range(5))
endpoint_name = "heart-classifier-" + endpoint_suffix

print(f"Endpoint name: {endpoint_name}")

Konfigurieren des Endpunkts

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: heart-classifier-edp
auth_mode: key

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An endpoint to serve predictions of the UCI heart disease problem",
    auth_mode="key",
)

Wir können die Eigenschaften dieses Endpunkts mithilfe einer Konfigurationsdatei konfigurieren. Wir konfigurieren den Authentifizierungsmodus des Endpunkts als "Schlüssel" im folgenden Beispiel:

endpoint_config = {
    "auth_mode": "key",
    "identity": {
        "type": "system_assigned"
    }
}

Schreiben Sie diese Konfiguration in eine JSON-Datei:

endpoint_config_path = "endpoint_config.json"
with open(endpoint_config_path, "w") as outfile:
    outfile.write(json.dumps(endpoint_config))

Erstellen des Endpunkts:

az ml online-endpoint create -n $ENDPOINT_NAME -f endpoint.yml

ml_client.online_endpoints.begin_create_or_update(endpoint).result()

endpoint = deployment_client.create_endpoint(
    name=endpoint_name,
    config={"endpoint-config-file": endpoint_config_path},
)

Abrufen des Authentifizierungsgeheimnisses für den Endpunkt
```
ENDPOINT_SECRET_KEY=$(az ml online-endpoint get-credentials -n $ENDPOINT_NAME | jq -r ".accessToken")
```
```
endpoint_secret_key = ml_client.online_endpoints.list_keys(
    name=endpoint_name
).access_token
```
Diese Funktionalität ist im MLflow nicht verfügbar. Wechseln Sie zu Azure Machine Learning Studio, navigieren Sie zum Endpunkt, und rufen Sie den geheimen Schlüssel von dort ab.

Erstellen einer Blau-Bereitstellung

Bisher ist der Endpunkt leer. Es sind keine Bereitstellungen vorhanden. Wir erstellen die erste, indem wir dasselbe Modell bereitstellen, an dem wir zuvor gearbeitet haben. Diese Bereitstellung wird als "Standard" bezeichnet, die unsere "blaue Bereitstellung" darstellt.

Konfigurieren der Bereitstellung

blue-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: default
endpoint_name: heart-classifier-edp
model: azureml:heart-classifier@latest
instance_type: Standard_DS2_v2
instance_count: 1

blue_deployment_name = "default"

Konfigurieren Sie die Hardwareanforderungen Ihrer Bereitstellung:

blue_deployment = ManagedOnlineDeployment(
    name=blue_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Wenn Ihr Endpunkt keine ausgehende Verbindung hat, können Sie Ihre Modelle packen (Vorschau), indem Sie das with_package=True-Argument einschließen:

blue_deployment = ManagedOnlineDeployment(
    name=blue_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
    with_package=True,
)

blue_deployment_name = "default"

Zum Konfigurieren der Hardwareanforderungen Ihrer Bereitstellung müssen Sie eine JSON-Datei mit der gewünschten Konfiguration erstellen:

deploy_config = {
    "instance_type": "Standard_DS2_v2",
    "instance_count": 1,
}

Hinweis

Die vollständige Spezifikation dieser Konfiguration finden Sie unter Verwaltetes Onlinebereitstellungsschema (v2).

Schreiben Sie die Konfiguration in eine Datei:

deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))

Erstellen der Bereitstellung

az ml online-deployment create --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Wenn Ihr Endpunkt keine ausgehende Verbindung hat, können Sie Ihre Modelle packen (Vorschau), indem Sie das Flag --with-package einschließen:

az ml online-deployment create --with-package --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Tipp

Wir legen das Flag --all-traffic im create-Befehl fest, sodass der gesamte Datenverkehr der neuen Bereitstellung zugewiesen wird.

ml_client.online_deployments.begin_create_or_update(blue_deployment).result()

blue_deployment = deployment_client.create_deployment(
    name=blue_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)

Zuweisen des gesamten Datenverkehrs zur Bereitstellung

Bisher verfügt der Endpunkt über genau eine Bereitstellung, es ist aber kein Datenverkehr zugewiesen. Dieser wird jetzt zugewiesen.
Dieser Schritt in ist in der Azure CLI nicht erforderlich, da wir bei der Erstellung --all-traffic verwendet haben.
```
endpoint.traffic = { blue_deployment_name: 100 }
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Schreiben Sie die Konfiguration in eine Datei:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Aktualisieren Sie die Endpunktkonfiguration:
Dieser Schritt in ist in der Azure CLI nicht erforderlich, da wir bei der Erstellung --all-traffic verwendet haben.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```

Erstellen einer Beispieleingabe zum Testen der Bereitstellung

sample.yml

{
    "input_data": {
        "columns": [
            "age",
            "sex",
            "cp",
            "trestbps",
            "chol",
            "fbs",
            "restecg",
            "thalach",
            "exang",
            "oldpeak",
            "slope",
            "ca",
            "thal"
        ],
        "data": [
            [ 48, 0, 3, 130, 275, 0, 0, 139, 0, 0.2, 1, 0, "normal" ]
        ]
    }
}

Im folgenden Code werden 5 Beobachtungen aus dem Trainingsdataset als Stichprobe entnommen, die Spalte target wird entfernt (da sie vom Modell vorhergesagt wird), und in der Datei sample.json wird eine Anforderung erstellt, die mit der Modellimplementierung verwendet werden kann.

samples = (
    pd.read_csv("data/heart.csv")
    .sample(n=5)
    .drop(columns=["target"])
    .reset_index(drop=True)
)

with open("sample.json", "w") as f:
    f.write(
        json.dumps(
            {"input_data": json.loads(samples.to_json(orient="split", index=False))}
        )
    )

Im folgenden Code werden 5 Beobachtungen aus dem Trainingsdataset als Stichprobe entnommen, die Spalte target wird entfernt (da sie vom Modell vorhergesagt wird), und eine Anforderung wird erstellt.

samples = (
    pd.read_csv("data/heart.csv")
    .sample(n=5)
    .drop(columns=["target"])
    .reset_index(drop=True)
)

Testen der Bereitstellung

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file sample.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample.json",
)

deployment_client.predict(
    endpoint=endpoint_name, 
    df=samples
)

Erstellen einer Grün-Bereitstellung unter dem Endpunkt

Angenommen, es gibt eine neue Version des Modells, die vom Entwicklungsteam erstellt wurde und bereit für die Produktion ist. Wir können dieses Modell zuerst testweise einsetzen, und sobald wir sicher sind, können wir den Endpunkt aktualisieren, um den Datenverkehr dorthin weiterzuleiten.

Registrieren einer neuen Modellversion

MODEL_NAME='heart-classifier'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "model"

Rufen wir die Versionsnummer des neuen Modells ab:

VERSION=$(az ml model show -n heart-classifier --label latest | jq -r ".version")

model_name = 'heart-classifier'
model_local_path = "model"

model = ml_client.models.create_or_update(
     Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)
version = model.version

model_name = 'heart-classifier'
model_local_path = "model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Konfigurieren einer neuen Bereitstellung

green-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: xgboost-model
endpoint_name: heart-classifier-edp
model: azureml:heart-classifier@latest
instance_type: Standard_DS2_v2
instance_count: 1

Wir benennen die Bereitstellung wie folgt:

GREEN_DEPLOYMENT_NAME="xgboost-model-$VERSION"

green_deployment_name = f"xgboost-model-{version}"

Konfigurieren Sie die Hardwareanforderungen Ihrer Bereitstellung:

green_deployment = ManagedOnlineDeployment(
    name=green_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Wenn Ihr Endpunkt keine ausgehende Verbindung hat, können Sie Ihre Modelle packen (Vorschau), indem Sie das with_package=True-Argument einschließen:

green_deployment = ManagedOnlineDeployment(
    name=green_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
    with_package=True,
)

green_deployment_name = f"xgboost-model-{version}"

Zum Konfigurieren der Hardwareanforderungen Ihrer Bereitstellung müssen Sie eine JSON-Datei mit der gewünschten Konfiguration erstellen:

deploy_config = {
    "instance_type": "Standard_DS2_v2",
    "instance_count": 1,
}

Tipp

Wir verwenden dieselbe Hardwarebestätigung, die in deployment-config-file angegeben ist. Es gibt jedoch keine Anforderung, dass dieselbe Konfiguration verwendet werden muss. Je nach Anforderung können Sie unterschiedliche Hardware für unterschiedliche Modelle konfigurieren.

Schreiben Sie die Konfiguration in eine Datei:

deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))

Erstellen der neuen Bereitstellung

az ml online-deployment create -n $GREEN_DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME -f green-deployment.yml

Wenn Ihr Endpunkt keine ausgehende Verbindung hat, können Sie Ihre Modelle packen (Vorschau), indem Sie das Flag --with-package einschließen:

az ml online-deployment create --with-package -n $GREEN_DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME -f green-deployment.yml

ml_client.online_deployments.begin_create_or_update(green_deployment).result()

new_deployment = deployment_client.create_deployment(
    name=green_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)

Testen der Bereitstellung ohne Änderung des Datenverkehrs

az ml online-endpoint invoke --name $ENDPOINT_NAME --deployment-name $GREEN_DEPLOYMENT_NAME --request-file sample.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=green_deployment_name
    request_file="sample.json",
)

deployment_client.predict(
    endpoint=endpoint_name, 
    deployment_name=green_deployment_name, 
    df=samples
)

Tipp

Beachten Sie, dass wir jetzt den Namen der Bereitstellung angeben, die wir aufrufen möchten.

Schrittweises Aktualisieren des Datenverkehrs

Sobald wir mit der neuen Bereitstellung zufrieden sind, können wir den Datenverkehr so aktualisieren, dass ein Teil davon an die neue Bereitstellung weitergeleitet wird. Datenverkehr wird auf Endpunktebene konfiguriert:

Konfigurieren des Datenverkehrs:

Dieser Schritt in ist in der Azure CLI nicht erforderlich.

endpoint.traffic = {blue_deployment_name: 90, green_deployment_name: 10}

traffic_config = {"traffic": {blue_deployment_name: 90, green_deployment_name: 10}}

Schreiben Sie die Konfiguration in eine Datei:

traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))

Aktualisieren des Endpunkts

az ml online-endpoint update --name $ENDPOINT_NAME --traffic "default=90 $GREEN_DEPLOYMENT_NAME=10"

ml_client.begin_create_or_update(endpoint).result()

deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)

Wenn Sie den gesamten Datenverkehr auf die neue Bereitstellung umstellen möchten, aktualisieren Sie den gesamten Datenverkehr:
Dieser Schritt in ist in der Azure CLI nicht erforderlich.
```
endpoint.traffic = {blue_deployment_name: 0, green_deployment_name: 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 0, green_deployment_name: 100}}
```
Schreiben Sie die Konfiguration in eine Datei:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```

Aktualisieren des Endpunkts

az ml online-endpoint update --name $ENDPOINT_NAME --traffic "default=0 $GREEN_DEPLOYMENT_NAME=100"

ml_client.begin_create_or_update(endpoint).result()

deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)

Da die alte Bereitstellung keinen Datenverkehr empfängt, können Sie ihn sicher löschen:
```
az ml online-deployment delete --endpoint-name $ENDPOINT_NAME --name default
```
```
ml_client.online_deployments.begin_delete(
    name=blue_deployment_name, 
    endpoint_name=endpoint_name
)
```
```
deployment_client.delete_deployment(
    blue_deployment_name, 
    endpoint=endpoint_name
)
```
Tipp

Beachten Sie, dass an diesem Punkt die frühere „Blau-Bereitstellung“ gelöscht wurde und die neue „Grün-Bereitstellung“ die Stelle der „Blau-Bereitstellung“ eingenommen hat.

Bereinigen von Ressourcen

az ml online-endpoint delete --name $ENDPOINT_NAME --yes

ml_client.online_endpoints.begin_delete(name=endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Wichtig

Beachten Sie, dass durch das Löschen eines Endpunkts auch alle darunter befindlichen Bereitstellungen gelöscht werden.

Freigeben über

Progressiver Rollout von MLflow-Modellen für Onlineendpunkte

Über dieses Beispiel

Folgen in Jupyter Notebooks

Voraussetzungen

Herstellen einer Verbindung mit Ihrem Arbeitsbereich

Registrieren des Modells in der Registrierung

Erstellen eines Onlineendpunkts

Erstellen einer Blau-Bereitstellung

Erstellen einer Grün-Bereitstellung unter dem Endpunkt

Schrittweises Aktualisieren des Datenverkehrs

Bereinigen von Ressourcen

Nächste Schritte

Feedback

Zusätzliche Ressourcen