Verwenden eines benutzerdefinierten Containers zum Bereitstellen eines Modells für einen Onlineendpunkt

GILT FÜR:Azure CLI ml Erweiterung v2 (aktuell)Python SDK azure-ai-ml v2 (aktuell)

In Azure Machine Learning können Sie einen benutzerdefinierten Container verwenden, um ein Modell auf einem Onlineendpunkt bereitzustellen. Benutzerdefinierte Containerbereitstellungen können andere Webserver als den standardmäßigen Python Flask-Server verwenden, der Azure Machine Learning verwendet.

Wenn Sie eine benutzerdefinierte Bereitstellung verwenden, können Sie:

• Verwenden Sie verschiedene Tools und Technologien wie TensorFlow Serving (TF Serving), TorchServe, Triton Inference Server, das Plumber R-Paket und das Azure Machine Learning Minimal-Image.
• Nutzen Sie dennoch die integrierte Überwachung, Skalierung, Warnung und Authentifizierung, die Azure Machine Learning bietet.

In diesem Artikel wird erklärt, wie Sie ein TF Serving-Image verwenden, um ein TensorFlow-Modell bereitzustellen.

Prerequisites

• Ein Azure Machine Learning Arbeitsbereich. Anweisungen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen des Arbeitsbereichs.

• Die Azure CLI und die erweiterung ml oder das Azure Machine Learning Python SDK v2:

  • Azure CLI
  • Python SDK

  Informationen zum Installieren des Azure CLI und der erweiterung ml finden Sie unter Install und Einrichten der CLI (v2).

  In den Beispielen in diesem Artikel wird davon ausgegangen, dass Sie eine Bash-Shell oder eine kompatible Shell verwenden. Sie können beispielsweise eine Shell auf einem Linux-System oder Windows Subsystem for Linux verwenden.

• Eine Azure-Ressourcengruppe, die Ihren Arbeitsbereich enthält und zu der entweder Sie oder Ihr Dienstprinzipal Mitwirkender-Zugriff haben. Wenn Sie die Schritte unter "Arbeitsbereich erstellen" verwenden, um Ihren Arbeitsbereich zu konfigurieren, erfüllen Sie diese Anforderung.

• Docker-Modul, lokal installiert und ausgeführt. Diese Voraussetzung wird dringend empfohlen. Sie benötigen es, um ein Modell lokal bereitzustellen, und es ist hilfreich für das Debuggen.

Bereitstellungsbeispiele

In der folgenden Tabelle sind Deployment examples aufgeführt, die benutzerdefinierte Container verwenden und verschiedene Tools und Technologien nutzen.

In diesem Artikel erfahren Sie, wie Sie das tfserving/half-plus-two Beispiel verwenden.

Herunterladen des Quellcodes

Die Schritte in diesem Artikel verwenden Codebeispiele aus dem Repository azureml-examples. Führen Sie die folgenden Befehle aus, um das Repository zu klonen:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Initialisieren von Umgebungsvariablen

Um ein TensorFlow-Modell zu verwenden, benötigen Sie mehrere Umgebungsvariablen. Führen Sie die folgenden Befehle aus, um diese Variablen zu definieren:

BASE_PATH=endpoints/online/custom-container/tfserving/half-plus-two
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1

Herunterladen eines TensorFlow-Modells

Laden Sie ein Modell herunter, und entpacken Sie ein Modell, das einen Eingabewert durch zwei dividiert, und fügt dem Ergebnis zwei hinzu:

wget https://aka.ms/half_plus_two-model -O $BASE_PATH/half_plus_two.tar.gz
tar -xvf $BASE_PATH/half_plus_two.tar.gz -C $BASE_PATH

Lokales Testen eines TF Serving-Images

Verwenden Sie Docker, um Ihr Image lokal zum Testen auszuführen:

docker run --rm -d -v $PWD/$BASE_PATH:$MODEL_BASE_PATH -p 8501:8501 \
 -e MODEL_BASE_PATH=$MODEL_BASE_PATH -e MODEL_NAME=$MODEL_NAME \
 --name="tfserving-test" docker.io/tensorflow/serving:latest
sleep 10

Verfügbarkeits- und Bewertungsanforderungen an das Image senden

Senden Sie eine Liveness-Anforderung, um zu überprüfen, ob der Prozess innerhalb des Containers ausgeführt wird. Sie sollten den Antwortstatuscode 200 OK erhalten.

curl -v http://localhost:8501/v1/models/$MODEL_NAME

Senden Sie eine Bewertungsanforderung, um zu überprüfen, ob Sie Vorhersagen für nicht bezeichnete Daten erhalten können:

curl --header "Content-Type: application/json" \
  --request POST \
  --data @$BASE_PATH/sample_request.json \
  http://localhost:8501/v1/models/$MODEL_NAME:predict

Beenden des Images

Wenn Sie den Test lokal abgeschlossen haben, beenden Sie das Bild:

docker stop tfserving-test

Bereitstellen Ihres Onlineendpunkts zum Azure

Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihren Onlineendpunkt für Azure bereitzustellen.

$schema: https://azuremlsdk2.blob.core.windows.net/latest/managedOnlineEndpoint.schema.json
name: tfserving-endpoint
auth_mode: aml_token

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: <model-version>
  path: ./half_plus_two
environment_variables:
  MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/<model-version>
  MODEL_NAME: half_plus_two
environment:
  #name: tfserving
  #version: 1
  image: docker.io/tensorflow/serving:latest
  inference_config:
    liveness_route:
      port: 8501
      path: /v1/models/half_plus_two
    readiness_route:
      port: 8501
      path: /v1/models/half_plus_two
    scoring_route:
      port: 8501
      path: /v1/models/half_plus_two:predict
instance_type: Standard_DS3_v2
instance_count: 1

# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

online_endpoint_name = "endpoint-" + datetime.datetime.now().strftime("%m%d%H%M%f")

# Configure an online endpoint.
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="A sample online endpoint",
    auth_mode="key",
    tags={"env": "dev"},
)

# create a blue deployment
model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

env = Environment(
    image="docker.io/tensorflow/serving:latest",
    inference_config={
        "liveness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "readiness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "scoring_route": {"port": 8501, "path": "/v1/models/half_plus_two:predict"},
    },
)

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    environment_variables={
        "MODEL_BASE_PATH": "/var/azureml-app/azureml-models/tfserving-mounted/1",
        "MODEL_NAME": "half_plus_two",
    },
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

In den folgenden Abschnitten werden wichtige Konzepte zu den PARAMETERn YAML und Python erläutert.

Basisbild

Geben Sie im Abschnitt environment in YAML oder im Environment-Konstruktor in Python das Basisbild als Parameter an. In diesem Beispiel wird docker.io/tensorflow/serving:latest als Wert für image verwendet.

Wenn Sie Ihren Container überprüfen, können Sie sehen, dass dieser Server ENTRYPOINT-Befehle verwendet, um ein Einstiegsskript zu starten. Dieses Skript verwendet Umgebungsvariablen wie MODEL_BASE_PATH und MODEL_NAME, und es macht Ports wie 8501 verfügbar. Diese Details beziehen sich alle auf diesen Server, und Sie können diese Informationen verwenden, um zu bestimmen, wie Ihre Bereitstellung definiert wird. Wenn Sie beispielsweise die MODEL_BASE_PATH Variablen und MODEL_NAME Umgebungsvariablen in Ihrer Bereitstellungsdefinition festlegen, verwendet TF Serving diese Werte, um den Server zu initiieren. Ebenso werden Benutzeranfragen bei Festlegung des Ports für jede Route auf 8501 in der Bereitstellungsdefinition ordnungsgemäß an den TF-Serving-Server weitergeleitet.

Dieses Beispiel basiert auf dem TF Serving-Fall. Sie können jedoch jeden Container verwenden, der aktiv bleibt und auf Anforderungen reagiert, die an Routen für Verfügbarkeit, Bereitschaft und Bewertung gesendet werden. Um zu sehen, wie man eine Dockerfile erstellt, um einen Container zu erstellen, schauen Sie sich andere Beispiele an. Einige Server verwenden CMD Anweisungen anstelle von ENTRYPOINT Anweisungen.

Der Parameter „inference_config“

Im environment Abschnitt oder in der Environment Klasse ist inference_config ein Parameter. Gibt den Port und Pfad für drei Arten von Routen an: Verfügbarkeits-, Bereitschafts- und Bewertungsrouten. Der inference_config Parameter ist erforderlich, wenn Sie Ihren eigenen Container mit einem verwalteten Onlineendpunkt ausführen möchten.

Bereitschaftsrouten im Vergleich zu Liveness-Routen

Einige API-Server bieten eine Möglichkeit, den Status des Servers zu überprüfen. Es gibt zwei Arten von Routen, die Sie für die Überprüfung des Status angeben können:

• Liveness-Routen: Um zu überprüfen, ob ein Server läuft, verwenden Sie eine Liveness-Route.
• Bereitschaftsrouten : Verwenden Sie eine Bereitschaftsroute, um zu überprüfen, ob ein Server für die Arbeit bereit ist.

Im Kontext der Ableitung des maschinellen Lernens reagiert ein Server möglicherweise mit einem Statuscode von 200 OK auf eine Livenessanforderung, bevor ein Modell geladen wird. Der Server antwortet möglicherweise mit einem Statuscode von 200 OK auf eine Bereitschaftsanforderung, nachdem es das Modell in den Arbeitsspeicher geladen hat.

Weitere Informationen zu Verfügbarkeits- und Bereitschaftstests finden Sie unter Konfigurieren von Verfügbarkeits-, Bereitschafts- und Starttests.

Der von Ihnen ausgewählte API-Server bestimmt die Verfügbarkeits- und Bereitschaftsrouten. Sie identifizieren diesen Server in einem früheren Schritt, wenn Sie den Container lokal testen. In diesem Artikel verwendet die Beispielbereitstellung denselben Pfad für die Verfügbarkeits- und Bereitschaftsrouten, da TF Serving nur eine Verfügbarkeitsroute definiert. Weitere Möglichkeiten zum Definieren der Routen finden Sie in anderen Beispielen.

Punktevergabevorgänge

Der verwendete API-Server bietet eine Möglichkeit, die Nutzdaten zu empfangen, um daran zu arbeiten. Im Kontext der Machine Learning-Ableitung empfängt ein Server die Eingabedaten über eine bestimmte Route. Identifizieren Sie diese Route für Ihren API-Server, wenn Sie den Container lokal in einem früheren Schritt testen. Geben Sie diese Route als Bewertungsroute an, wenn Sie die zu erstellende Bereitstellung definieren.

Die erfolgreiche Erstellung der Bereitstellung aktualisiert auch den scoring_uri-Parameter des Endpunkts. Sie können diese Tatsache überprüfen, indem Sie den folgenden Befehl ausführen: az ml online-endpoint show -n <endpoint-name> --query scoring_uri.

Suchen des eingebundenen Modells

Wenn Sie ein Modell als Onlineendpunkt bereitstellen, Azure Machine Learning mounts Ihr Modell an Ihren Endpunkt. Wenn das Modell bereitgestellt wird, können Sie neue Versionen des Modells bereitstellen, ohne ein neues Docker-Image erstellen zu müssen. Standardmäßig befindet sich ein Modell, das mit dem Namen "my-model " und "Version 1 " registriert ist, im folgenden Pfad innerhalb Ihres bereitgestellten Containers: /var/azureml-app/azureml-models/my-model/1.

Betrachten Sie z. B. die folgende Einrichtung:

• Eine Verzeichnisstruktur auf Ihrem lokalen Computer von /azureml-examples/cli/endpoints/online/custom-container
• Modellname half_plus_two

model:
    name: tfserving-mounted
    version: 1
    path: ./half_plus_two

model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

Wenn Sie eine Bereitstellung erstellen, befindet sich Ihr Modell in diesem Fall unter dem folgenden Ordner: /var/azureml-app/azureml-models/tfserving-mounted/1

Sie können optional Ihren model_mount_path Wert konfigurieren. Durch Anpassen dieser Einstellung können Sie den Pfad ändern, in dem das Modell bereitgestellt wird.

Wenn Sie den Wert ändern model_mount_path, müssen Sie auch die MODEL_BASE_PATH Umgebungsvariable aktualisieren. Setzen Sie MODEL_BASE_PATH auf denselben Wert wie model_mount_path, um eine fehlgeschlagene Bereitstellung aufgrund eines Fehlers zu vermeiden, dass der Basispfad nicht gefunden wird.

name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: 1
  path: ./half_plus_two
model_mount_path: /var/tfserving-model-mount
environment_variables:
  MODEL_BASE_PATH: /var/tfserving-model-mount
...

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    model_mount_path="/var/tfserving-model-mount",
    environment_variables={
        "MODEL_BASE_PATH": "/var/tfserving-model-mount",
    ...
)

In Ihrer Bereitstellung befindet sich Ihr Modell unter /var/tfserving-model-mount/tfserving-mounted/1. Er befindet sich nicht mehr unter azureml-app/azureml-models, sondern unter dem Einbindungspfad, den Sie angeben.

Erstellen Sie Ihren Endpunkt und die Bereitstellung

az ml online-endpoint create --name tfserving-endpoint -f endpoints/online/custom-container/tfserving/half-plus-two/tfserving-endpoint.yml

az ml online-deployment create --name tfserving-deployment -f endpoints/online/custom-container/tfserving/half-plus-two/tfserving-deployment.yml --all-traffic

ml_client.begin_create_or_update(endpoint)

ml_client.begin_create_or_update(blue_deployment)

Aufrufen des Endpunkts

Wenn Die Bereitstellung abgeschlossen ist, stellen Sie eine Bewertungsanforderung an den bereitgestellten Endpunkt.

RESPONSE=$(az ml online-endpoint invoke -n $ENDPOINT_NAME --request-file $BASE_PATH/sample_request.json)

# Test the blue deployment by using some sample data.
response = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample_request.json",
)

Löschen des Endpunkts

Wenn Sie Ihren Endpunkt nicht mehr benötigen, führen Sie den folgenden Befehl aus, um ihn zu löschen:

az ml online-endpoint delete --name tfserving-endpoint

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Verwandte Inhalte

• Durchführen der sicheren Bereitstellung neuer Anwendungen für Echtzeitrückschlüsse
• Problembehandlung für die Bereitstellung und Bewertung von Onlineendpunkten
• Torch-Serve-Beispiel