Trainieren von Scikit-learn-Modellen im großen Stil mit Azure Machine Learning

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

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

Mit den Beispielskripts in diesem Artikel werden Irisbilder zum Erstellen eines Machine Learning-Modells auf der Grundlage des Iris-Datasets von Scikit-learn klassifiziert.

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

Voraussetzungen

Sie können den Code für diesen Artikel entweder in einer Azure Machine Learning-Compute-Instanz oder auf Ihrem eigenen Jupyter Notebook-Server ausführen.

• Azure Machine Learning-Computeinstanz

  • Schließen Sie Ressourcen erstellen, um zu beginnen ab, um eine Compute-Instanz zu erstellen. Jede Compute-Instanz enthält einen dedizierten Notebook-Server, der vorab mit dem SDK und dem Notebook-Beispielrepository geladen wurde.
  • Klicken Sie im Azure Machine Learning Studio auf die Registerkarte „Notebook“. Im Beispieltrainingsordner finden Sie im folgenden Ordner ein fertiges und erweitertes Notebook: v2 > sdk > jobs > single-step > scikit-learn > train-hyperparameter-tune-deploy-with-sklearn.
  • Sie können den vorab aufgefüllten Code im Beispieltrainingsordner verwenden, um dieses Tutorial durchzugehen.

• Ihr Jupyter Notebook-Server.

  • Installieren des Azure Machine Learning SDK (v2).

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 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 Kommentare im folgenden Code entfernen 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

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. Für dieses Beispiel benötigen wir nur einen einfachen Cluster. Wir wählen daher ein Standard_DS3_v2-Modell mit 2 vCPU-Kernen und 7 GB RAM aus, um eine Azure Machine Learning-Compute-Instanz zu erstellen.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"

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

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

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        name=cpu_compute_target,
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # 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
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster).result()

print(
    f"AMLCompute with name {cpu_cluster.name} is created, the compute size is {cpu_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 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 env genannt.

import os

dependencies_dir = "./env"
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: sklearn-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pip:  
    - azureml-mlflow==1.42.0
    - mlflow-skinny==2.3.2

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

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 = "sklearn-env"

job_env = Environment(
    name=custom_env_name,
    description="Custom environment for sklearn 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.

[Optional] Erstellen einer benutzerdefinierten Umgebung mit Intel®-Erweiterung für Scikit-Learn

Möchten Sie Ihre Scikit-Learn-Skripts auf Intel-Hardware beschleunigen? Versuchen Sie, die Intel®-Erweiterung für Scikit-Learn zu Ihrer Conda-YAML-Datei hinzuzufügen, und folgen Sie den nachfolgenden Schritten weiter oben. Wir zeigen Ihnen später in diesem Beispiel, wie Sie diese Optimierungen aktivieren:

%%writefile {dependencies_dir}/conda.yaml
name: sklearn-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scikit-learn-intelex
  - scipy=1.7.1
  - pip:  
    - azureml-mlflow==1.42.0
    - mlflow-skinny==2.3.2

Konfigurieren und Übermitteln Ihres Trainingsauftrags

In diesem Abschnitt erfahren Sie, wie Sie einen Trainingsauftrag mithilfe eines Trainingsskripts ausführen, das wir bereitgestellt haben. Zu Beginn erstellen Sie den Trainingsauftrag, indem Sie den Befehl zum Ausführen des Trainingsskripts konfigurieren. Dann übermitteln Sie den Trainingsauftrag zur Ausführung in Azure Machine Learning.

Vorbereiten des Trainingsskripts

In diesem Artikel haben wir das Trainingsskript train_iris.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.

Hinweis

Das bereitgestellte Trainingsskript erledigt Folgendes:

• Es zeigt, wie Sie einige Metriken in Ihrer Azure Machine Learning-Ausführung protokollieren.
• Es verwendet iris = datasets.load_iris(), um die Trainingsdaten herunterzuladen und zu extrahieren.
• Es trainiert ein Modell, um dieses dann zu speichern und zu registrieren.

Wenn Sie eigene Daten verwenden und darauf zugreifen möchten, lesen Sie die Informationen zum Lesen und Schreiben von Daten in einem Auftrag, um Daten während des Trainings verfügbar zu machen.

Um das Trainingsskript zu verwenden, erstellen Sie zunächst ein Verzeichnis, in dem Sie die Datei speichern werden.

import os

src_dir = "./src"
os.makedirs(src_dir, exist_ok=True)

Als nächstes erstellen Sie die Skriptdatei im Quellverzeichnis.

%%writefile {src_dir}/train_iris.py
# Modified from https://www.geeksforgeeks.org/multiclass-classification-using-scikit-learn/

import argparse
import os

# importing necessary libraries
import numpy as np

from sklearn import datasets
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split

import joblib

import mlflow
import mlflow.sklearn

def main():
    parser = argparse.ArgumentParser()

    parser.add_argument('--kernel', type=str, default='linear',
                        help='Kernel type to be used in the algorithm')
    parser.add_argument('--penalty', type=float, default=1.0,
                        help='Penalty parameter of the error term')

    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    args = parser.parse_args()
    mlflow.log_param('Kernel type', str(args.kernel))
    mlflow.log_metric('Penalty', float(args.penalty))

    # loading the iris dataset
    iris = datasets.load_iris()

    # X -> features, y -> label
    X = iris.data
    y = iris.target

    # dividing X, y into train and test data
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

    # training a linear SVM classifier
    from sklearn.svm import SVC
    svm_model_linear = SVC(kernel=args.kernel, C=args.penalty)
    svm_model_linear = svm_model_linear.fit(X_train, y_train)
    svm_predictions = svm_model_linear.predict(X_test)

    # model accuracy for X_test
    accuracy = svm_model_linear.score(X_test, y_test)
    print('Accuracy of SVM classifier on test set: {:.2f}'.format(accuracy))
    mlflow.log_metric('Accuracy', float(accuracy))
    # creating a confusion matrix
    cm = confusion_matrix(y_test, svm_predictions)
    print(cm)

    registered_model_name="sklearn-iris-flower-classify-model"

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=svm_model_linear,
        registered_model_name=registered_model_name,
        artifact_path=registered_model_name
    )

    # # Saving the model to a file
    print("Saving the model via MLFlow")
    mlflow.sklearn.save_model(
        sk_model=svm_model_linear,
        path=os.path.join(registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    mlflow.end_run()

if __name__ == '__main__':
    main()

[Optional] Aktivieren der Intel®-Erweiterung für Scikit-Learn-Optimierungen für mehr Leistung auf Intel-Hardware

Wenn Sie die Intel®-Erweiterung für Scikit-Learn (wie im vorherigen Abschnitt gezeigt) installiert haben, können Sie die Leistungsoptimierungen aktivieren, indem Sie die beiden Codezeilen oben in der Skriptdatei hinzufügen, wie unten gezeigt.

Weitere Informationen zur Intel®-Erweiterung für Scikit-Learn finden Sie in der Dokumentation des Pakets.

%%writefile {src_dir}/train_iris.py
# Modified from https://www.geeksforgeeks.org/multiclass-classification-using-scikit-learn/

import argparse
import os

# Import and enable Intel Extension for Scikit-learn optimizations
# where possible

from sklearnex import patch_sklearn
patch_sklearn()

# importing necessary libraries
import numpy as np


from sklearn import datasets
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split

import joblib

import mlflow
import mlflow.sklearn

def main():
    parser = argparse.ArgumentParser()

    parser.add_argument('--kernel', type=str, default='linear',
                        help='Kernel type to be used in the algorithm')
    parser.add_argument('--penalty', type=float, default=1.0,
                        help='Penalty parameter of the error term')

    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    args = parser.parse_args()
    mlflow.log_param('Kernel type', str(args.kernel))
    mlflow.log_metric('Penalty', float(args.penalty))

    # loading the iris dataset
    iris = datasets.load_iris()

    # X -> features, y -> label
    X = iris.data
    y = iris.target

    # dividing X, y into train and test data
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

    # training a linear SVM classifier
    from sklearn.svm import SVC
    svm_model_linear = SVC(kernel=args.kernel, C=args.penalty)
    svm_model_linear = svm_model_linear.fit(X_train, y_train)
    svm_predictions = svm_model_linear.predict(X_test)

    # model accuracy for X_test
    accuracy = svm_model_linear.score(X_test, y_test)
    print('Accuracy of SVM classifier on test set: {:.2f}'.format(accuracy))
    mlflow.log_metric('Accuracy', float(accuracy))
    # creating a confusion matrix
    cm = confusion_matrix(y_test, svm_predictions)
    print(cm)

    registered_model_name="sklearn-iris-flower-classify-model"

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=svm_model_linear,
        registered_model_name=registered_model_name,
        artifact_path=registered_model_name
    )

    # # Saving the model to a file
    print("Saving the model via MLFlow")
    mlflow.sklearn.save_model(
        sk_model=svm_model_linear,
        path=os.path.join(registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    mlflow.end_run()

if __name__ == '__main__':
    main()

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. Zum Ausführen des Auftrags erstellen wir einen Befehl (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 Befehl (command), um das Trainingsskript und die gewünschten Aufgaben auszuführen. Erstellen Sie ein Command-Objekt, um die Konfigurationsdetails Ihres Trainingsauftrags anzugeben.

• 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:
  • Geben Sie den Computecluster cpu_compute_target = "cpu-cluster" an, den Sie für die Ausführung dieses Befehls erstellt haben.
  • Geben Sie die benutzerdefinierte Umgebung sklearn-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 train_iris.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.

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

job = command(
    inputs=dict(kernel="linear", penalty=1.0),
    compute=cpu_compute_target,
    environment=f"{job_env.name}:{job_env.version}",
    code="./src/",
    command="python train_iris.py --kernel ${{inputs.kernel}} --penalty ${{inputs.penalty}}",
    experiment_name="sklearn-iris-flowers",
    display_name="sklearn-classify-iris-flower-images",
)

Ü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 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 Ausführungsverlauf 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 der Cluster mehr Knoten zur Ausführung benötigt, 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 von stdout und dem Ordner ./logs werden in den Ausführungsverlauf gestreamt und können zum Überwachen der Ausführung verwendet werden.

Optimieren von Modellhyperparametern

Nachdem Sie gesehen haben, wie eine einfache Scikit-learn-Trainingsausführung über das SDK stattfindet, geht es nun darum, ob Sie die Genauigkeit Ihres Modells weiter verbessern können. Sie können die Hyperparameter unseres 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 (kernel und penalty), die an den Trainingsauftrag übergeben werden, durch spezielle Eingaben aus dem Paket azure.ml.sweep.

from azure.ai.ml.sweep import Choice

# 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(
    kernel=Choice(values=["linear", "rbf", "poly", "sigmoid"]),
    penalty=Choice(values=[0.5, 1, 1.5]),
)

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 Accuracy zu maximieren.

sweep_job = job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm="random",
    primary_metric="Accuracy",
    goal="Maximize",
    max_total_trials=12,
    max_concurrent_trials=4,
)

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 "sklearn-iris-flower-classify-model"
        path="azureml://jobs/{}/outputs/artifacts/paths/sklearn-iris-flower-classify-model/".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
        )
    )

Dieses Modell können Sie dann registrieren.

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

Bereitstellen des Modells

Nachdem Sie Ihr Modell registriert haben, können Sie es auf die gleiche Weise bereitstellen wie jedes andere registrierte Modell in Azure Machine Learning. Weitere Informationen zur Bereitstellung finden Sie unter Bereitstellen und Bewerten eines Machine Learning-Modells mit verwaltetem Onlineendpunkt mithilfe des Python SDK v2.

Nächste Schritte

In diesem Artikel haben Sie ein scikit-learn-Modell trainiert und registriert und sich über Bereitstellungsoptionen informiert. Weitere Informationen zu Azure Machine Learning finden Sie in den folgenden Artikeln.

• Erfassen einer Ausführungsmetrik während des Trainings
• Optimieren von Hyperparametern