Schnellstart: Erste Schritte mit Azure Machine Learning

Artikel
10/16/2024

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

Dieses Tutorial ist eine Einführung in einige der am häufigsten verwendeten Funktionen des Azure Machine Learning Service. In diesem Tutorial werden Sie ein Modell erstellen, registrieren und bereitstellen. Dieses Tutorial hilft Ihnen dabei, sich mit den Kernkonzepten von Azure Machine Learning und den gängigsten Anwendungsfällen vertraut zu machen.

Sie erfahren, wie Sie einen Trainingsauftrag für eine skalierbare Computeressource ausführen, dann bereitstellen und schließlich die Bereitstellung testen.

Sie erstellen ein Trainingsskript, um die Datenaufbereitung zu verarbeiten sowie ein Modell zu trainieren und zu registrieren. Nachdem Sie das Modell trainiert haben, stellen Sie es als Endpunkt bereit. Rufen Sie dann den Endpunkt für Rückschlüsse auf.

Auszuführende Schritte:

Einrichten eines Handles für Ihren Azure Machine Learning-Arbeitsbereich
Erstellen Ihres Trainingsskripts
Erstellen einer skalierbaren Computeressource, eines Computeclusters
Erstellen und Ausführen eines Befehlsauftrags, der das Trainingsskript auf dem Computecluster ausführt, der mit der entsprechenden Auftragsumgebung konfiguriert ist
Anzeigen der Ausgabe Ihres Trainingsskripts
Bereitstellen des neu trainierten Modells als Endpunkt
Aufrufen des Azure Machine Learning-Endpunkts für Rückschlüsse

Sehen Sie sich dieses Video an, um einen Überblick über die Schritte in diesem Schnellstart zu erhalten.

Voraussetzungen

Um Azure Machine Learning zu verwenden, benötigen Sie einen Arbeitsbereich. Wenn Sie noch keinen haben, schließen Sie Erstellen von Ressourcen, die Sie für die ersten Schritte benötigen ab, um einen Arbeitsbereich zu erstellen, und mehr über dessen Verwendung zu erfahren.
Melden Sie sich bei Studio an, und wählen Sie Ihren Arbeitsbereich aus, falls dieser noch nicht geöffnet ist.
Öffnen oder erstellen Sie ein neues Notebook in Ihrem Arbeitsbereich:
- Wenn Sie Code in Zellen kopieren und einfügen möchten, erstellen Sie ein neues Notebook.
- Alternativ öffnen Sie im Abschnitt Beispiele von Studio die Datei tutorials/get-started-notebooks/quickstart.ipynb. Wählen Sie dann Klonen aus, um das Notebook zu Ihren Dateien hinzuzufügen. Informationen zum Suchen nach Beispielnotebooks finden Sie unter Lernen aus Beispielnotebooks.

Festlegen des Kernels und Öffnen in Visual Studio Code (VS Code)

Erstellen Sie auf der oberen Leiste über Ihrem geöffneten Notizbuch eine Compute-Instanz, falls Sie noch keine besitzen.
Wenn die Compute-Instanz beendet wurde, wählen Sie Compute starten aus, und warten Sie, bis sie ausgeführt wird.
Warten Sie, bis die Compute-Instanz ausgeführt wird. Stellen Sie dann sicher, dass der rechts oben zu findende Kernel Python 3.10 - SDK v2 ist. Falls nicht, verwenden Sie die Dropdownliste, um diesen Kernel auszuwählen.

Wenn dieser Kernel nicht angezeigt wird, überprüfen Sie, ob Ihre Compute-Instanz ausgeführt wird. Falls ja, wählen Sie oben rechts im Notebook die Schaltfläche Aktualisieren aus.
Wenn Sie ein Banner mit dem Hinweis sehen, dass Sie authentifiziert werden müssen, wählen Sie Authentifizieren aus.
Sie können das Notebook hier ausführen oder es in VS Code öffnen, um eine vollständig integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) mit der Leistungsfähigkeit von Azure Machine Learning-Ressourcen nutzen zu können. Wählen Sie In VS Code öffnen und dann unter „In VS Code bearbeiten“ entweder die Option „Web“ oder „Desktop“ aus. Wenn Sie den VS Code-Editor auf diese Weise starten, wird er an Ihre Compute-Instanz, den Kernel und das Dateisystem des Arbeitsbereichs angefügt.

Wichtig

Der Rest dieses Tutorials enthält Zellen des Tutorial-Notebooks. Kopieren Sie diese und fügen sie in Ihr neues Notebook ein, oder wechseln Sie jetzt zum Notebook, wenn Sie es geklont haben.

Erstellen eines Handles für den Arbeitsbereich

Bevor wir uns genauer mit dem Code befassen, benötigen Sie eine Möglichkeit, um auf Ihren Arbeitsbereich zu verweisen. 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.

Sie erstellen ml_client als Handle für den Arbeitsbereich. Anschließend verwenden Sie ml_client zum Verwalten von Ressourcen und Aufträgen.

Geben Sie in der nächsten Zelle Ihre Abonnement-ID, den Namen der Ressourcengruppe und den Namen des Arbeitsbereichs ein. So finden Sie diese Werte:

Wählen Sie auf der oben rechts angezeigten Azure Machine Learning Studio-Symbolleiste den Namen Ihres Arbeitsbereichs aus.
Kopieren Sie den Wert für Arbeitsbereich, Ressourcengruppe und Abonnement-ID in den Code.
Sie müssen einen Wert kopieren, den Bereich schließen und einfügen und den Vorgang dann für den nächsten wiederholen.

Screenshot: Suchen der Anmeldeinformationen für Ihren Code rechts oben auf der Symbolleiste.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

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

Hinweis

Beim Erstellen von MLClient wird keine Verbindung mit dem Arbeitsbereich hergestellt. Die Clientinitialisierung erfolgt verzögert, d. h., es wird abgewartet, bis das erste Mal ein Aufruf erforderlich ist (dies geschieht in der nächsten Codezelle).

# Verify that the handle works correctly.
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location, ":", ws.resource_group)

Erstellen des Trainingsskripts

Beginnen wir mit der Erstellung des Trainingsskripts, der Python-Datei main.py.

Erstellen Sie zunächst einen Quellordner für das Skript:

import os

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

Dieses Skript behandelt die Vorverarbeitung der Daten, indem es sie in Test- und Trainingsdaten aufteilt. Anschließend werden diese Daten verwendet, um ein strukturbasiertes Modell zu trainieren und das Ausgabemodell zurückzugeben.

MLFlow wird verwendet, um während unserer Pipelineausführung die Parameter und Metriken zu protokollieren.

In der folgenden Zelle wird die Datei mithilfe von des IPython Magic-Befehls in das Trainingsskript geschrieben, das Sie gerade erstellt haben.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))
    ###################
    #</train the model>
    ###################

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

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Wie Sie in diesem Skript sehen können, wird die Modelldatei gespeichert und im Arbeitsbereich registriert, nachdem das Modell trainiert wurde. Jetzt können Sie das registrierte Modell in Rückschlussendpunkten verwenden.

Möglicherweise müssen Sie Aktualisieren auswählen, um den neuen Ordner und das Skript in Ihren Dateien anzuzeigen.

Screenshot des Symbols „Aktualisieren“.

Konfigurieren des Befehls

Da Sie nun über ein Skript zum Ausführen der gewünschten Aufgaben sowie einen Computecluster zum Ausführen des Skripts verfügen, verwenden Sie einen universellen Befehl, der Befehlszeilenaktionen ausführen kann. Diese Befehlszeilenaktion kann direkt Systembefehle aufrufen oder ein Skript ausführen.

Hier erstellen Sie Eingabevariablen, um die Eingabedaten, das Aufteilungsverhältnis, die Lernrate und den Namen des registrierten Modells anzugeben. Das Befehlsskript führt folgende Aktionen aus:

Verwenden Sie eine Umgebung, die Software- und Laufzeitbibliotheken definiert, die für das Trainingsskript erforderlich sind. Azure Machine Learning bietet viele kuratierte oder vordefinierte Umgebungen, die für allgemeine Trainings- und Rückschlussszenarien nützlich sind. An dieser Stelle verwenden Sie eine der Umgebungen. Unter Tutorial: Training eines Modells in Azure Machine Learning wird erläutert, wie Sie eine benutzerdefinierte Umgebung erstellen.
Es konfiguriert die eigentliche Befehlszeilenaktion, in diesem Fall python main.py. Die Ein- und Ausgaben werden mittels ${{ ... }}-Notation im Befehl angegeben.
In diesem Beispiel greifen wir auf die Daten aus einer Datei im Internet zu.
Da keine Computeressource angegeben wurde, wird das Skript auf einem serverlosen Computecluster ausgeführt, der automatisch erstellt wird.

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

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    display_name="credit_default_prediction",
)

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

ml_client.create_or_update(job)

Anzeigen der Auftragsausgabe und Warten auf den Auftragsabschluss

Zeigen Sie den Auftrag in Azure Machine Learning Studio an, indem Sie den Link in der Ausgabe der vorherigen Zelle auswählen.

Die Ausgabe dieses Auftrags sieht in Azure Machine Learning Studio wie folgt aus. Sehen Sie sich die Registerkarten für verschiedene Details wie Metriken und Ausgaben an. Nach Abschluss des Vorgangs registriert der Auftrag als Ergebnis des Trainings ein Modell in Ihrem Arbeitsbereich.

Screenshot: Übersichtsseite des Auftrags.

Wichtig

Warten Sie, bis der Status des Auftrags „Abgeschlossen“ lautet, bevor Sie zu diesem Notizbuch zurückkehren, um den Vorgang fortzusetzen. Die Auftragsausführung dauert 2 bis 3 Minuten. Es kann länger (bis zu 10 Minuten) dauern, wenn der Computecluster auf null Knoten skaliert wurde und die benutzerdefinierte Umgebung noch erstellt wird.

Bereitstellen des Modells als Onlineendpunkt

Stellen Sie Ihr Machine Learning-Modell nun als Webdienst in der Azure-Cloud (online endpoint) bereit.

Zum Bereitstellen eines Machine Learning-Diensts verwenden Sie das Modell, das Sie registriert haben.

Erstellen eines neuen Onlineendpunkts

Da Sie nun über ein registriertes Modell verfügen, ist es an der Zeit, Ihren Onlineendpunkt zu erstellen. Der Endpunktname muss innerhalb der Azure-Region eindeutig sein. In diesem Tutorial erstellen Sie mithilfe von UUID einen eindeutigen Namen.

import uuid

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

Erstellen des Endpunkts:

# Expect the endpoint creation to take a few minutes
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

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

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

Hinweis

Die Erstellung des Endpunkts dauert einige Minuten.

Nachdem der Endpunkt erstellt wurde, können Sie ihn wie folgt abrufen:

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

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

Bereitstellen des Modells für den Endpunkt

Nachdem der Endpunkt erstellt wurde, stellen Sie das Modell mit dem Einstiegsskript bereit. Jeder Endpunkt kann mehrere Bereitstellungen aufweisen. Mithilfe von Regeln kann der direkte Datenverkehr an diese Bereitstellungen angegeben werden. Hier erstellen Sie eine einzelne Bereitstellung, die den eingehenden Datenverkehr vollständig verarbeitet. Wir haben einen Farbnamen für die Bereitstellung verwendet (z. B. blue, green, red), der willkürlich gewählt wurde.

Sie können die Seite Modelle im Azure Machine Learning Studio aufrufen, um die aktuelle Version Ihres registrierten Modells zu ermitteln. Alternativ dazu ruft der folgende Code die neueste zu verwendende Versionsnummer ab.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)
print(f'Latest model is version "{latest_model_version}" ')

Stellen Sie die aktuelle Version des Modells bereit.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

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

Hinweis

Die Bereitstellung kann ungefähr 6 bis 8 Minuten in Anspruch nehmen.

Wenn die Bereitstellung abgeschlossen ist, können Sie sie testen.

Testen mit einer Beispielabfrage

Sobald das Modell auf dem Endpunkt bereitgestellt wurde, können Sie es nun für Rückschlüsse nutzen.

Erstellen Sie eine Beispielanforderungsdatei, die dem in der run-Methode des Bewertungsskripts erwarteten Format entspricht.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Bereinigen von Ressourcen

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

Hinweis

Der vollständige Löschvorgang dauert ungefähr 20 Minuten.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Beenden der Compute-Instanz

Wenn Sie die Compute-Instanz jetzt nicht verwenden möchten, beenden Sie sie:

Wählen Sie im Studio im linken Navigationsbereich Compute aus.
Wählen Sie auf den oberen Registerkarten Compute-Instanzen aus.
Wählen Sie in der Liste die Compute-Instanz aus.
Wählen Sie auf der oberen Symbolleiste Beenden aus.

Löschen aller Ressourcen

Wichtig

Die von Ihnen erstellten Ressourcen können ggf. auch in anderen Azure Machine Learning-Tutorials und -Anleitungen verwendet werden.

Wenn Sie die erstellten Ressourcen nicht mehr benötigen, löschen Sie diese, damit Ihnen keine Kosten entstehen:

Geben Sie im Azure-Portal im Suchfeld Ressourcengruppen ein, und wählen Sie diese aus den Ergebnissen aus.
Wählen Sie in der Liste die Ressourcengruppe aus, die Sie erstellt haben.
Wählen Sie auf der Seite Übersicht die Option Ressourcengruppe löschen aus.
Geben Sie den Ressourcengruppennamen ein. Wählen Sie anschließend die Option Löschen.

Nächste Schritte

Nachdem Sie nun eine Vorstellung davon haben, was beim Trainieren und Bereitstellen eines Modells zu beachten ist, erfahren Sie in den folgenden Tutorials mehr über den Prozess:

Lernprogramm	Beschreibung
Hochladen, Zugreifen auf und Erkunden von Daten in Azure Machine Learning	Speichern großer Daten in der Cloud und Abrufen der Daten aus Notebooks und Skripts
Modellentwicklung in einer Cloudarbeitsstation	Starten der Prototyperstellung und Entwicklung von Machine Learning-Modellen
Training eines Modells in Azure Machine Learning	Erfahren Sie mehr über die Details zum Trainieren eines Modells
Bereitstellen eines Modells als ein Onlineendpunkt	Erfahren Sie mehr über die Details der Bereitstellung eines Modells
Erstellen von Produktionspipelines für maschinelles Lernen	Teilen Sie eine vollständige Machine Learning-Aufgabe in einen mehrstufigen Workflow auf.

Teilen über

Schnellstart: Erste Schritte mit Azure Machine Learning

Voraussetzungen

Festlegen des Kernels und Öffnen in Visual Studio Code (VS Code)

Erstellen eines Handles für den Arbeitsbereich

Erstellen des Trainingsskripts

Konfigurieren des Befehls

Übermitteln des Auftrags

Anzeigen der Auftragsausgabe und Warten auf den Auftragsabschluss

Bereitstellen des Modells als Onlineendpunkt

Erstellen eines neuen Onlineendpunkts

Bereitstellen des Modells für den Endpunkt

Testen mit einer Beispielabfrage

Bereinigen von Ressourcen

Beenden der Compute-Instanz

Löschen aller Ressourcen

Nächste Schritte

Feedback

Zusätzliche Ressourcen