Bedarfsgerechtes Trainieren von PyTorch-Modellen mit Azure Machine Learning

  • Artikel

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

In diesem Artikel erfahren Sie, wie Sie ein PyTorch-Modell mit dem Azure Machine Learning Python SDK v2 trainieren, bereitstellen und Hyperparameter dafür optimieren.

Sie verwenden Beispielskripts, um Hühner- und Truthahnbilder zu klassifizieren, um ein neuronales Deep Learning-Netz (DNN) aufzubauen, basierend auf dem Tutorial zum Transferlernen von PyTorch. Lerntransfer ist ein Verfahren, bei dem das bei der Lösung eines Problems gewonnene Wissen auf ein anderes, aber verwandtes Problem angewandt wird. Transferlernen verkürzt den Trainingsprozess, da weniger Daten, Zeit und Computeressourcen benötigt werden als bei einem von Grund auf durchgeführten Training. Weitere Informationen zum Lerntransfer finden Sie unter Deep Learning im Vergleich zu maschinellem Lernen.

Unabhängig davon, ob Sie ein PyTorch-Deep Learning-Modell von Grund auf trainieren, oder ob Sie ein vorhandenes Modell in die Cloud bringen, können Sie Azure Machine Learning zum Aufskalieren von Open-Source-Trainingsaufträgen mithilfe elastischer Cloud-Computeressourcen verwenden. Sie können produktionsgeeignete Modelle mit Azure Machine Learning erstellen, bereitstellen, überwachen sowie die Versionen verwalten.

Voraussetzungen

  • Ein Azure-Abonnement. 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):
      • Schließen Sie den Schnellstart: Erste Schritte mit Azure Machine Learning ab, um einen dedizierten Notebook-Server zu erstellen, der mit dem SDK und dem Beispielrepository vorab geladen ist.
      • Suchen Sie unter der Registerkarte Beispiele im Abschnitt Notebooks Ihres Arbeitsbereichs ein abgeschlossenes und erweitertes Notebook, indem Sie zu diesem Verzeichnis navigieren: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
    • Ihr Jupyter Notebook-Server:

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

Zuerst müssen Sie eine Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich herstellen. Der 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 bei Ihnen nicht funktioniert, schauen Sie unter Azure.Identity-Paket oder Einrichten der Authentifizierung für 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 Ihre 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 können.

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 Berechnungserstellung.

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 stellen wir einen Linux-Computecluster bereit. Sie können die Azure Machine Learning-Preisseite für die vollständige Liste der VM-Größen und -Preise anzeigen. 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 verwenden Sie die kuratierte Azure Machine Learning-Umgebung AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu. Verwenden Sie die neueste Version dieser Umgebung mithilfe der @latest-Anweisung.

curated_env_name = "AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu@latest"

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 können das Dataset in dieser gezippten Datei verwenden. Dieses Dataset besteht aus etwa 120 Trainingsbildern, jeweils für zwei Klassen (Truthähne und Hühner), mit 100 Validierungsbildern für jede Klasse. Die Bilder sind eine Teilmenge des Open Images v5 Dataset. Das Schulungsskript pytorch_train.py lädt das Dataset herunter und extrahiert es.

Vorbereiten des Trainingsskripts

Im Abschnitt „Voraussetzungen“ haben wir das Schulungsskript pytorch_train.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 lädt die Daten herunter, trainiert ein Modell und registriert das Modell.

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 erstellen wir ein command.

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 Input

job = command(
    inputs=dict(
        num_epochs=30, learning_rate=0.001, momentum=0.9, output_dir="./outputs"
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",  # location of source code
    command="python pytorch_train.py --num_epochs ${{inputs.num_epochs}} --output_dir ${{inputs.output_dir}}",
    experiment_name="pytorch-birds",
    display_name="pytorch-birds-image",
)
  • Die Eingaben für diesen Befehl umfassen die Anzahl von Epochen, Lernrate, Dynamik und Ausgabeverzeichnis.
  • Führen Sie für die Parameterwerte folgende Schritte aus:
    1. Geben Sie das Computecluster gpu_compute_target = "gpu-cluster" an, das Sie für die Ausführung dieses Befehls erstellt haben.
    2. Stellen Sie die zusammengestellte Umgebung AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu bereit, die Sie zuvor initialisiert haben.
    3. Wenn Sie das fertige Notebook nicht im Ordner „Beispiele“ verwenden, geben Sie den Speicherort der pytorch_train.py-Datei an.
    4. Konfigurieren Sie die eigentliche Befehlszeilenaktion, in diesem Fall mit dem Befehl python pytorch_train.py. Sie können über die ${{ ... }}-Notation auf die Eingaben und Ausgaben im Befehl zugreifen.
    5. 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.

Ü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 auf 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, die an den Trainingsauftrag übergeben werden, durch spezielle Eingaben aus dem Paket azure.ml.sweep.

Da das Trainingsskript einen Lernratenplan verwendet, um die Lernrate alle paar Epochen zu verringern, können Sie die anfängliche Lernrate und die Dynamikparameter einstellen.

from azure.ai.ml.sweep import Uniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
job_for_sweep = job(
    learning_rate=Uniform(min_value=0.0005, max_value=0.005),
    momentum=Uniform(min_value=0.9, max_value=0.99),
)

Anschließend können Sie den Befehlsauftrag mit einigen Sweep-spezifischen Parametern konfigurieren, 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 best_val_acc zu maximieren.

Wir definieren auch eine Richtlinie zur vorzeitigen Beendigung, die BanditPolicy, um leistungsschwache Ausführungen frühzeitig zu beenden. Die BanditPolicy beendet jede Ausführung, die nicht innerhalb des Pufferfaktors unserer primären Auswertungsmetrik liegt. Sie wenden diese Richtlinie in jeder Epoche an (da wir unsere best_val_acc-Metrik jede Epoche melden und evaluation_interval=1). Beachten Sie, dass wir die erste Auswertung der Richtlinie erst nach den ersten 10 Epochen (delay_evaluation=10) vornehmen.

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute="gpu-cluster",
    sampling_algorithm="random",
    primary_metric="best_val_acc",
    goal="Maximize",
    max_total_trials=8,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(
        slack_factor=0.15, evaluation_interval=1, delay_evaluation=10
    ),
)

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.

Ermitteln 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 "outputs"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/".format(best_run),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

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

Bereitstellen des Modells als Onlineendpunkt

Sie können Ihr Modell jetzt als Onlineendpunkt bereitstellen, d. h. 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 = "aci-birds-endpoint-" + str(uuid.uuid4())[:8]
from azure.ai.ml.entities import ManagedOnlineEndpoint

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify turkey/chickens using transfer learning with PyTorch",
    auth_mode="key",
    tags={"data": "birds", "method": "transfer learning", "framework": "pytorch"},
)

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

print(f"Endpoint {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

Sie können das Modell jetzt 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 haben wir für die Bereitstellung einen beliebigen Farbnamen aci-blue angegeben. Sie können auch einen anderen Namen wie aci-green oder aci-red für die Bereitstellung verwenden.

Der Code zum Bereitstellen des Modells am Endpunkt:

  • Stellt die beste Version des Modells bereit, das Sie zuvor registriert haben.
  • Bewertet das Modell mithilfe der score.py-Datei.
  • Verwendet die zusammengestellte Umgebung, die Sie zuvor angegeben haben, um dem Rückschluss durchzuführen.
from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    Model,
    Environment,
    CodeConfiguration,
)

online_deployment_name = "aci-blue"

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name=online_deployment_name,
    endpoint_name=online_endpoint_name,
    model=model,
    environment=curated_env_name,
    code_configuration=CodeConfiguration(code="./score/", scoring_script="score.py"),
    instance_type="Standard_NC6s_v3",
    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 verwenden wir ein Beispielbild für die Vorhersage. Lassen Sie uns zunächst das Bild anzeigen.

# install pillow if PIL cannot imported
%pip install pillow
import json
from PIL import Image
import matplotlib.pyplot as plt

%matplotlib inline
plt.imshow(Image.open("test_img.jpg"))

Erstellen Sie eine Funktion zur Formatierung und Größenänderung des Bilds.

# install torch and torchvision if needed
%pip install torch
%pip install torchvision

import torch
from torchvision import transforms


def preprocess(image_file):
    """Preprocess the input image."""
    data_transforms = transforms.Compose(
        [
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ]
    )

    image = Image.open(image_file)
    image = data_transforms(image).float()
    image = torch.tensor(image)
    image = image.unsqueeze(0)
    return image.numpy()

Formatieren Sie das Bild, und wandeln Sie es in eine JSON-Datei um.

image_data = preprocess("test_img.jpg")
input_data = json.dumps({"data": image_data.tolist()})
with open("request.json", "w") as outfile:
    outfile.write(input_data)

Sie können dann den Endpunkt mit dieser JSON-Datei aufrufen und das Ergebnis ausgeben.

# test the blue deployment
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="request.json",
    deployment_name=online_deployment_name,
)

print(result)

Bereinigen von Ressourcen

Wenn Sie den Endpunkt nicht mehr benötigen, 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 neuronales Deep Learning-Netz mithilfe von PyTorch in Azure Machine Learning trainiert und registriert. Sie haben das Modell auch auf einem Onlineendpunkt bereitgestellt. Weitere Informationen zu Azure Machine Learning finden Sie in den folgenden Artikeln.