Bedarfsgerechtes Trainieren von Keras-Modellen mit Azure Machine Learning

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

In diesem Artikel erfahren Sie, wie Sie Ihre Keras-Trainingsskripts mit dem Azure Machine Learning Python SDK v2 ausführen.

Der Beispielcode in diesem Artikel verwendet Azure Machine Learning zum Trainieren, Registrieren und Bereitstellen eines Keras-Modells, das mithilfe des TensorFlow-Back-Ends erstellt wurde. Das Modell ist ein DNN (Deep Neural Network), das mit der Keras-Python-Bibliothek erstellt wurde, die auf TensorFlow ausgeführt wird. Es klassifiziert handschriftliche Ziffern aus dem gängigen MNIST-Dataset.

Keras ist eine allgemeine API für neuronale Netzwerke, die zur Vereinfachung der Entwicklung auf anderen beliebten DNN-Frameworks ausgeführt werden kann. Azure Machine Learning bietet die Möglichkeit, Trainingsaufträge mithilfe elastischer Cloudcomputeressourcen schnell horizontal zu skalieren. Sie können auch Ihre Trainingsläufe, Versions- und Bereitstellungsmodelle und vieles mehr nachverfolgen.

Egal, ob Sie ein Keras-Modell von Grund auf entwickeln oder ein bestehendes Modell in die Cloud bringen, Azure Machine Learning kann Ihnen helfen, produktionsreife Modelle zu erstellen.

Hinweis

Wenn Sie die in TensorFlow integrierte Keras-API tf.keras und nicht das eigenständige Keras-Paket verwenden, lesen Sie stattdessen Trainieren von TensorFlow-Modellen.

Voraussetzungen

Damit dieser Artikel für Sie nützlich ist, müssen Sie folgende Schritte ausführen:

• Greifen Sie auf ein Azure-Abonnement zu. Sollten Sie noch keines besitzen, können Sie ein kostenloses Konto erstellen.
• Führen Sie den Code in diesem Artikel in einer Azure Machine Learning-Compute-Instanz oder in Ihrem eigenen Jupyter Notebook aus.
  • Azure Machine Learning-Compute-Instanz – weder Download noch Installation erforderlich:
    • Führen Sie Erstellen von Ressourcen für die ersten Schritte durch, um einen dedizierten Notebookserver zu erstellen, auf dem das SDK und das Beispielrepository vorinstalliert sind.
    • Im Deep Learning-Beispielordner auf dem Notebook-Server finden Sie ein vollständiges und erweitertes Notebook. Navigieren Sie zum folgenden Verzeichnis: v2 > sdk > python > jobs > single-step > tensorflow > train-hyperparameter-tune-deploy-with-keras.
  • Ihr Jupyter Notebook-Server
    • Installieren des Azure Machine Learning SDK (v2).
• Laden Sie die Trainingsskripts keras_mnist.py und utils.py herunter.

Auf der GitHub-Seite mit Beispielen finden Sie außerdem eine fertige Jupyter Notebook-Version dieser Anleitung.

Bevor Sie den Code in diesem Artikel ausführen können, um einen GPU-Cluster zu erstellen, müssen Sie für Ihren Arbeitsbereich eine Kontingenterhöhung anfordern.

Einrichten des Auftrags

In diesem Abschnitt wird der Auftrag für das Training eingerichtet, indem Sie die erforderlichen Python-Pakete laden, eine Verbindung mit einem Arbeitsbereich herstellen, eine Computeressource zum Ausführen eines Befehlsauftrags erstellen und eine Umgebung zum Ausführen des Auftrags erstellen.

Herstellen einer Verbindung mit dem Arbeitsbereich

Als Erstes müssen Sie eine Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich herstellen. Der Azure Machine Learning-Arbeitsbereich ist die Ressource der obersten Ebene für den Dienst. Er bietet Ihnen einen zentralen Ort für die Arbeit mit allen Artefakten, die Sie bei der Verwendung von Azure Machine Learning erstellen.

Sie verwenden DefaultAzureCredential, um Zugriff auf den Arbeitsbereich zu erhalten. Diese Anmeldeinformationen sollten die meisten Azure SDK-Authentifizierungsszenarien abdecken können.

Wenn DefaultAzureCredential für Sie nicht funktioniert, finden Sie unter azure-identity reference documentation und Set up authentication weitere verfügbare Anmeldeinformationen.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Wenn Sie sich lieber über einen Browser anmelden und authentifizieren möchten, sollten Sie stattdessen die Auskommentierung des folgenden Codes aufheben und diesen verwenden.

# Handle to the workspace
# from azure.ai.ml import MLClient

# Authentication package
# from azure.identity import InteractiveBrowserCredential
# credential = InteractiveBrowserCredential()

Rufen Sie als Nächstes ein Handle für den Arbeitsbereich ab, indem Sie Ihre Abonnement-ID, den Namen der Ressourcengruppe und den Namen des Arbeitsbereichs angeben. So finden Sie diese Parameter

1. Suchen Sie in der rechten oberen Ecke der Symbolleiste von Azure Machine Learning Studio nach dem Namen Ihres Arbeitsbereichs.
2. Wählen Sie den Namen Ihres Arbeitsbereichs aus, um die Ressourcengruppe und die Abonnement-ID anzuzeigen.
3. Kopieren Sie die Werte für die Ressourcengruppe und die Abonnement-ID in den Code.

# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id="<SUBSCRIPTION_ID>",
    resource_group_name="<RESOURCE_GROUP>",
    workspace_name="<AML_WORKSPACE_NAME>",
)

Das Ausführen dieses Skripts führt zu einem Handle für den Arbeitsbereich, das Sie für die Verwaltung anderer Ressourcen und Aufträge verwenden.

Hinweis

• Beim Erstellen von MLClient wird keine Verbindung des Clients mit dem Arbeitsbereich hergestellt. Die Clientinitialisierung ist ein langsamer Vorgang, bei dem gewartet wird, bis erstmals ein Aufruf erfolgen muss. In diesem Artikel geschieht dies während der Computeerstellung.

Erstellen einer Computeressource zum Ausführen des Auftrags

Azure Machine Learning benötigt eine Computeressource, um einen Auftrag auszuführen. Bei dieser Ressource kann es sich um Computer mit einem oder mehreren Knoten mit Linux- oder Windows-Betriebssystemen oder um ein spezielles Computefabric wie Spark handeln.

Im folgenden Beispielskript wird ein Linux-compute cluster bereitgestellt. Auf der Seite Azure Machine Learning pricing finden Sie die vollständige Liste der VM-Größen und Preise. Da für dieses Beispiel ein GPU-Cluster benötigt wird, wählen Sie ein Modell des Typs STANDARD_NC6 aus und erstellen eine Azure Machine Learning-Computeressource.

from azure.ai.ml.entities import AmlCompute

gpu_compute_target = "gpu-cluster"

try:
    # let's see if the compute target already exists
    gpu_cluster = ml_client.compute.get(gpu_compute_target)
    print(
        f"You already have a cluster named {gpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new gpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    gpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="gpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_NC6s_v3",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )

    # Now, we pass the object to MLClient's create_or_update method
    gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()

print(
    f"AMLCompute with name {gpu_cluster.name} is created, the compute size is {gpu_cluster.size}"
)

Erstellen der Auftragsumgebung

Um einen Azure Machine Learning-Auftrag auszuführen, benötigen Sie eine Umgebung. Eine Azure Machine Learning-Umgebung kapselt die Abhängigkeiten (z. B. Softwareruntime und Bibliotheken), die zum Ausführen des Machine Learning-Trainingsskripts auf Ihrer Computeressource erforderlich sind. Diese Umgebung ähnelt einer Python-Umgebung auf Ihrem lokalen Computer.

Mit Azure Machine Learning können Sie entweder eine kuratierte (also vorgefertigte) Umgebung verwenden oder mithilfe eines Docker-Images oder einer Conda-Konfiguration eine benutzerdefinierte Umgebung erstellen. In diesem Artikel erstellen Sie eine benutzerdefinierte Conda-Umgebung für Ihre Aufträge mithilfe einer Conda-YAML-Datei.

Erstellen einer benutzerdefinierten Umgebung

Zum Erstellen Ihrer benutzerdefinierten Umgebung definieren Sie Ihre Conda-Abhängigkeiten in einer YAML-Datei. Erstellen Sie zunächst ein Verzeichnis zum Speichern der Datei. In diesem Beispiel haben wir das Verzeichnis dependencies genannt.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Dann erstellen Sie die Datei im Abhängigkeitsverzeichnis. In diesem Beispiel haben wir die Datei conda.yml genannt.

%%writefile {dependencies_dir}/conda.yaml
name: keras-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - pip:
    - protobuf~=3.20
    - numpy==1.22
    - tensorflow-gpu==2.2.0
    - keras<=2.3.1
    - matplotlib
    - azureml-mlflow==1.42.0

Die Spezifikation enthält einige übliche Pakete (wie numpy und pip), die Sie in Ihrem Auftrag verwenden werden.

Verwenden Sie anschließend die YAML-Datei, um diese benutzerdefinierte Umgebung in Ihrem Arbeitsbereich zu erstellen und zu registrieren. Die Umgebung wird zur Laufzeit in einen Docker-Container gepackt.

from azure.ai.ml.entities import Environment

custom_env_name = "keras-env"

job_env = Environment(
    name=custom_env_name,
    description="Custom environment for keras image classification",
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
job_env = ml_client.environments.create_or_update(job_env)

print(
    f"Environment with name {job_env.name} is registered to workspace, the environment version is {job_env.version}"
)

Weitere Informationen zum Erstellen und Verwenden von Umgebungen finden Sie unter Erstellen und Verwenden von Softwareumgebungen in Azure Machine Learning.

Konfigurieren und Übermitteln Ihres Trainingsauftrags

In diesem Abschnitt wird mit der Einführung der Daten für das Training begonnen. Anschließend wird behandelt, wie Sie einen Trainingsauftrag mit einem bereitgestellten Trainingsskript ausführen. Sie lernen, den Trainingsauftrag zu erstellen, indem Sie den Befehl zum Ausführen des Trainingsskript konfigurieren. Dann übermitteln Sie den Trainingsauftrag zur Ausführung in Azure Machine Learning.

Abrufen der Trainingsdaten

Sie verwenden Daten aus der MNIST-Datenbank (Modified National Institute of Standards and Technology) handschriftlicher Ziffern. Diese Daten werden von der Website von Yan LeCun abgerufen und in einem Azure Storage-Konto gespeichert.

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

Weitere Informationen zum MNIST-Dataset finden Sie auf der Website von Yan LeCun.

Vorbereiten des Trainingsskripts

In diesem Artikel haben Sie das Trainingsskript keras_mnist.py bereitgestellt. In der Praxis sollten Sie benutzerdefinierte Trainingsskripts unverändert übernehmen und mit Azure Machine Learning ausführen können, ohne Ihren Code ändern zu müssen.

Das bereitgestellte Trainingsskript erledigt Folgendes:

• Es übernimmt die Vorverarbeitung der Daten und teilt die Daten in Test- und Trainingsdaten auf.
• Es trainiert ein Modell mit den Daten.
• Es gibt das Ausgabemodell zurück.

Während der Pipelineausführung verwenden Sie MLflow, um die Parameter und Metriken zu protokollieren. Informationen zum Aktivieren der MLflow-Nachverfolgung finden Sie unter Nachverfolgen von ML-Experimenten und -Modellen mit MLflow.

Im Trainingsskript keras_mnist.py wird ein einfaches Deep Neural Network (DNN) erstellt. Dieses DNN weist Folgendes auf:

• Eine Eingabeschicht mit 28 × 28 = 784 Neuronen. Jedes Neuron stellt ein Bildpixel dar.
• Zwei verborgene Schichten. Die erste ausgeblendete Schicht verfügt über 300 Neuronen, und die zweite ausgeblendete Schicht verfügt über 100 Neuronen.
• Eine Ausgabeschicht mit 10 Neuronen. Jedes Neuron stellt eine zielgerichtete Bezeichnung von 0 bis 9 dar.

Erstellen des Trainingsauftrags

Sie verfügen jetzt über alle für die Ausführung des Auftrags erforderlichen Objekte und können den Auftrag mit dem Azure Machine Learning Python SDK v2 erstellen. In diesem Beispiel wird ein command erstellt.

In Azure Machine Learning ist ein command eine Ressource, die alle erforderlichen Details zum Ausführen Ihres Trainingscodes in der Cloud angibt. Diese Details umfassen die Eingaben und Ausgaben, die Art der zu verwendenden Hardware, zu installierende Software und Angaben zum Ausführen des Codes. Der command enthält Informationen zum Ausführen eines einzelnen Befehls.

Konfigurieren des Befehls

Sie verwenden den universellen command, um das Trainingsskript auszuführen und die gewünschten Aufgaben auszuführen. Erstellen Sie ein Command-Objekt, um die Konfigurationsdetails Ihres Trainingsauftrags anzugeben.

from azure.ai.ml import command
from azure.ai.ml import UserIdentityConfiguration
from azure.ai.ml import Input

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

job = command(
    inputs=dict(
        data_folder=Input(type="uri_folder", path=web_path),
        batch_size=50,
        first_layer_neurons=300,
        second_layer_neurons=100,
        learning_rate=0.001,
    ),
    compute=gpu_compute_target,
    environment=f"{job_env.name}:{job_env.version}",
    code="./src/",
    command="python keras_mnist.py --data-folder ${{inputs.data_folder}} --batch-size ${{inputs.batch_size}} --first-layer-neurons ${{inputs.first_layer_neurons}} --second-layer-neurons ${{inputs.second_layer_neurons}} --learning-rate ${{inputs.learning_rate}}",
    experiment_name="keras-dnn-image-classify",
    display_name="keras-classify-mnist-digit-images-with-dnn",
)

• Die Eingaben für diesen Befehl umfassen den Datenspeicherort, die Batchgröße, die Anzahl der Neuronen in der ersten und zweiten Schicht und die Lernrate. Beachten Sie, dass der Webpfad direkt als Eingabe übergeben wurde.

• Führen Sie für die Parameterwerte folgende Schritte aus:

  • Geben Sie den Computecluster gpu_compute_target = "gpu-cluster" an, den Sie für die Ausführung dieses Befehls erstellt haben.
  • Geben Sie die benutzerdefinierte Umgebung keras-env an, die Sie für die Ausführung des Azure Machine Learning-Auftrags erstellt haben.
  • Konfigurieren Sie die eigentliche Befehlszeilenaktion, in diesem Fall mit dem Befehl python keras_mnist.py. Sie können über die ${{ ... }}-Notation auf die Eingaben und Ausgaben im Befehl zugreifen.
  • Konfigurieren Sie Metadaten wie den Anzeigenamen und den Experimentnamen. Dabei ist ein Experiment ein Container für alle Iterationen, die für ein bestimmtes Projekt durchlaufen werden. Alle mit demselben Experimentnamen übermittelten Aufträge werden nebeneinander in Azure Machine Learning Studio aufgelistet.

• In diesem Beispiel verwenden Sie den UserIdentity, um den Befehl auszuführen. Die Verwendung einer Benutzeridentität bedeutet, dass der Befehl unter Ihrer Identität den Auftrag ausführt und auf die Daten aus dem Blob zugreift.

Übermitteln des Auftrags

Jetzt ist es an der Zeit, den Auftrag zur Ausführung in Azure Machine Learning zu übermitteln. Dieses Mal verwenden Sie create_or_update für ml_client.jobs.

ml_client.jobs.create_or_update(job)

Nach dem Abschluss registriert der Auftrag ein Modell in Ihrem Arbeitsbereich (als Ergebnis des Trainings) und gibt einen Link zum Anzeigen des Auftrags in Azure Machine Learning Studio aus.

Warnung

Zum Ausführen von Trainingsskripts wird von Azure Machine Learning das gesamte Quellverzeichnis kopiert. Sind vertrauliche Daten vorhanden, die nicht hochgeladen werden sollen, verwenden Sie eine IGNORE-Datei, oder platzieren Sie diese Daten nicht im Quellverzeichnis.

Was geschieht während der Auftragsausführung?

Die Ausführung des Auftrags durchläuft die folgenden Phasen:

• Vorbereitung: Ein Docker-Image wird entsprechend der definierten Umgebung erstellt. Das Image wird in die Containerregistrierung des Arbeitsbereichs hochgeladen und für spätere Ausführungen zwischengespeichert. Darüber hinaus werden Protokolle in den Auftragsverlauf gestreamt, mit deren Hilfe der Status überwacht werden kann. Bei Angabe einer zusammengestellten Umgebung wird das zwischengespeicherte Image verwendet, das diese zusammengestellte Umgebung unterstützt.

• Skalierung: Der Cluster versucht ein Hochskalieren, wenn mehr Knoten zur Ausführung benötigt werden, als derzeit verfügbar sind.

• Wird ausgeführt: Alle Skripts im Skriptordner src werden auf das Computeziel hochgeladen, Datenspeicher werden eingebunden oder kopiert, und das Skript wird ausgeführt. Ausgaben aus stdout und dem Ordner ./logs werden in den Auftragsverlauf gestreamt und können zur Überwachung des Auftrags verwendet werden.

Optimieren von Modellhyperparametern

Sie haben das Modell mit einem Satz von Parametern trainiert. Lassen Sie uns jetzt sehen, ob Sie die Genauigkeit Ihres Modells weiter verbessern können. Sie können die Hyperparameter Ihres Modells mithilfe der sweep-Funktionen von Azure Machine Learning fein abstimmen und optimieren.

Um die Hyperparameter des Modells zu optimieren, definieren Sie den Parameterraum, in dem während des Trainings gesucht werden soll. Dazu ersetzen Sie einige der Parameter (batch_size, first_layer_neurons, second_layer_neurons und learning_rate), die an den Trainingsauftrag übergeben werden, durch spezielle Eingaben aus dem Paket azure.ml.sweep.

from azure.ai.ml.sweep import Choice, LogUniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
# we do not apply the 'iris_csv' input again -- we will just use what was already defined earlier
job_for_sweep = job(
    batch_size=Choice(values=[25, 50, 100]),
    first_layer_neurons=Choice(values=[10, 50, 200, 300, 500]),
    second_layer_neurons=Choice(values=[10, 50, 200, 500]),
    learning_rate=LogUniform(min_value=-6, max_value=-1),
)

Anschließend konfigurieren Sie den Befehlsauftrag mit einigen Sweep-spezifischen Parametern, z. B. der primär zu überwachenden Metrik und dem zu verwendenden Stichprobenalgorithmus.

Im folgenden Code werden zufällige Stichproben verwendet, um verschiedene konfigurierte Hyperparametergruppen auszuprobieren und die primäre Metrik validation_acc zu maximieren.

Außerdem wird eine Richtlinie zur vorzeitigen Beendigung definiert, BanditPolicy. Diese Richtlinie überprüft den Auftrag alle zwei Iterationen. Wenn die primäre Metrik, validation_acc, außerhalb des Bereichs der oberen zehn Prozent liegt, beendet Azure Machine Learning den Auftrag. Dadurch wird das Modell daran gehindert, Hyperparameter zu verfolgen, die zum Erreichen der Zielmetrik nicht geeignet sind.

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute=gpu_compute_target,
    sampling_algorithm="random",
    primary_metric="Accuracy",
    goal="Maximize",
    max_total_trials=20,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(slack_factor=0.1, evaluation_interval=2),
)

Jetzt können Sie diesen Auftrag wie zuvor übermitteln. Diesmal führen Sie einen Sweepauftrag aus, der Ihren Trainingsauftrag durchläuft.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

Sie können den Auftrag mithilfe des Links zur Studio-Benutzeroberfläche überwachen, der während der Auftragsausführung angezeigt wird.

Suchen und Registrieren des besten Modells

Sobald alle Ausführungen abgeschlossen sind, können Sie nach der Ausführung suchen, die das Modell mit der höchsten Genauigkeit produziert hat.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "keras_dnn_mnist_model"
        path="azureml://jobs/{}/outputs/artifacts/paths/keras_dnn_mnist_model/".format(
            best_run
        ),
        name="run-model-example",
        description="Model created from run.",
        type="mlflow_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

Dieses Modell können Sie dann registrieren.

registered_model = ml_client.models.create_or_update(model=model)

Bereitstellen des Modells als Onlineendpunkt

Nachdem Sie Ihr Modell registriert haben, können Sie es als Onlineendpunkt bereitstellen, also als Webdienst in der Azure-Cloud.

Um einen Dienst für maschinelles Lernen bereitzustellen, benötigen Sie normalerweise Folgendes:

• Die Modellressourcen, die Sie bereitstellen möchten. Zu diesen Ressourcen gehören die Datei und die Metadaten des Modells, die Sie bereits in Ihrem Trainingsauftrag registriert haben.
• Code, der als Dienst ausgeführt werden soll. Der Code führt das Modell für eine bestimmte Eingabeanforderung (ein Einstiegsskript) aus. Dieses Einstiegsskript empfängt an einen bereitgestellten Webdienst übermittelte Daten und übergibt sie an das Modell. Nachdem das Modell die Daten verarbeitet hat, gibt das Skript die Antwort des Modells an den Client zurück. Das Skript ist modellspezifisch und muss die vom Modell erwarteten und zurückgegebenen Daten verstehen. Wenn Sie ein MLflow-Modell verwenden, erstellt Azure Machine Learning dieses Skript automatisch für Sie.

Weitere Informationen zur Bereitstellung finden Sie unter Bereitstellen und Bewerten eines Machine Learning-Modells mit verwaltetem Onlineendpunkt mithilfe des Python SDK v2.

Erstellen eines neuen Onlineendpunkts

Zum Bereitstellen Ihres Modells müssen Sie als Erstes Ihren Onlineendpunkt erstellen. Der Endpunktname muss innerhalb der gesamten Azure-Region eindeutig sein. Im Rahmen dieses Artikels erstellen Sie einen eindeutigen Namen mit einem universellen eindeutigen Bezeichner (UUID).

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "keras-dnn-endpoint-" + str(uuid.uuid4())[:8]

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

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify handwritten digits using a deep neural network (DNN) using Keras",
    auth_mode="key",
)

endpoint = ml_client.begin_create_or_update(endpoint).result()

print(f"Endpint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Nachdem Sie den Endpunkt erstellt haben, können Sie ihn wie folgt abrufen:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Bereitstellen des Modells für den Endpunkt

Nach dem Erstellen des Endpunkts können Sie das Modell mit dem Einstiegsskript bereitstellen. Ein Endpunkt kann mehrere Bereitstellungen aufweisen. Mithilfe von Regeln kann der Endpunkt dann den Datenverkehr an diese Bereitstellungen weiterleiten.

Im folgenden Code erstellen Sie eine einzige Bereitstellung, die 100 % des eingehenden Datenverkehrs verarbeitet. Hier wurde für die Bereitstellung ein beliebiger Farbname (tff-blue) angegeben. Sie können auch einen anderen Namen wie tff-grün oder tff-rot für die Bereitstellung verwenden. Der Code zum Bereitstellen des Modells auf dem Endpunkt führt Folgendes aus:

• Er stellt die beste Version des Modells bereit, das Sie zuvor registriert haben.
• Er bewertet das Modell mithilfe der Datei score.py.
• Er verwendet die benutzerdefinierte Umgebung, die Sie zuvor erstellt haben, um den Rückschluss durchzuführen.

from azure.ai.ml.entities import ManagedOnlineDeployment, CodeConfiguration

model = registered_model

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="keras-blue-deployment",
    endpoint_name=online_endpoint_name,
    model=model,
    # code_configuration=CodeConfiguration(code="./src", scoring_script="score.py"),
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Hinweis

Gehen Sie davon aus, dass diese Bereitstellung etwas Zeit in Anspruch nimmt.

Testen des bereitgestellten Modells

Nachdem Sie das Modell nun auf dem Endpunkt bereitgestellt haben, können Sie die Ausgabe des bereitgestellten Modells mithilfe der invoke-Methode auf dem Endpunkt vorhersagen.

Zum Testen des Endpunkts benötigen Sie einige Testdaten. Wir laden die Testdaten lokal herunter, die wir in unserem Trainingsskript verwendet haben.

import urllib.request

data_folder = os.path.join(os.getcwd(), "data")
os.makedirs(data_folder, exist_ok=True)

urllib.request.urlretrieve(
    "https://azureopendatastorage.blob.core.windows.net/mnist/t10k-images-idx3-ubyte.gz",
    filename=os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"),
)
urllib.request.urlretrieve(
    "https://azureopendatastorage.blob.core.windows.net/mnist/t10k-labels-idx1-ubyte.gz",
    filename=os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"),
)

Laden Sie diese in ein Testdataset.

from src.utils import load_data

X_test = load_data(os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"), False)
y_test = load_data(
    os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"), True
).reshape(-1)

Wählen Sie 30 zufällige Beispiele aus dem Testsatz aus, und schreiben Sie sie in eine JSON-Datei.

import json
import numpy as np

# find 30 random samples from test set
n = 30
sample_indices = np.random.permutation(X_test.shape[0])[0:n]

test_samples = json.dumps({"input_data": X_test[sample_indices].tolist()})
# test_samples = bytes(test_samples, encoding='utf8')

with open("request.json", "w") as outfile:
    outfile.write(test_samples)

Anschließend können Sie den Endpunkt aufrufen, die zurückgegebenen Vorhersagen drucken und zusammen mit den eingehenden Bildern grafisch darstellen. Verwenden Sie rote Schrift und ein inverses Bild (Weiß auf Schwarz), um falsch klassifizierte Stichproben hervorzuheben.

import matplotlib.pyplot as plt

# predict using the deployed model
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./request.json",
    deployment_name="keras-blue-deployment",
)

# compare actual value vs. the predicted values:
i = 0
plt.figure(figsize=(20, 1))

for s in sample_indices:
    plt.subplot(1, n, i + 1)
    plt.axhline("")
    plt.axvline("")

    # use different color for misclassified sample
    font_color = "red" if y_test[s] != result[i] else "black"
    clr_map = plt.cm.gray if y_test[s] != result[i] else plt.cm.Greys

    plt.text(x=10, y=-10, s=result[i], fontsize=18, color=font_color)
    plt.imshow(X_test[s].reshape(28, 28), cmap=clr_map)

    i = i + 1
plt.show()

Hinweis

Da die Modellgenauigkeit hoch ist, müssen Sie möglicherweise die Zelle einige Male ausführen, bevor Sie eine falsch klassifizierte Stichprobe sehen.

Bereinigen von Ressourcen

Wenn Sie den Endpunkt nicht verwenden, löschen Sie ihn, um die Verwendung der Ressource zu beenden. Vergewissern Sie sich, dass der Endpunkt nicht von anderen Bereitstellungen verwendet wird, bevor Sie ihn löschen.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Hinweis

Gehen Sie davon aus, dass diese Bereinigung etwas Zeit in Anspruch nimmt.

Nächste Schritte

In diesem Artikel haben Sie ein Keras-Modell trainiert und registriert. Sie haben das Modell auch auf einem Onlineendpunkt bereitgestellt. Weitere Informationen zu Azure Machine Learning finden Sie in den folgenden Artikeln.

• Erfassen einer Ausführungsmetrik während des Trainings
• Optimieren von Hyperparametern
• Verteiltes Trainieren von Deep Learning-Modellen in Azure