Schnellstart: Erste Schritte mit Azure Machine Learning

  • Artikel

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 erstellen, registrieren und stellen Sie ein Modell bereit. Dieses Tutorial hilft Ihnen dabei, sich mit den Kernkonzepten von Azure Machine Learning und den häufigsten 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. Wenn das Modell trainiert ist, stellen Sie es als Endpunkt bereit, und rufen 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

  1. Um Azure Machine Learning verwenden zu können, benötigen Sie zuerst 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.

  2. Melden Sie sich bei Studio an, und wählen Sie Ihren Arbeitsbereich aus, falls dieser noch nicht geöffnet ist.

  3. Öffnen oder erstellen Sie ein neues Notebook in Ihrem Arbeitsbereich:

    • Erstellen Sie ein neues Notebook, wenn Sie Code in Zellen kopieren/einfügen möchten.
    • 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. (Erfahren Sie, wo Beispiele zu finden sind.)

Festlegen Ihres Kernels

  1. Erstellen Sie auf der oberen Leiste über Ihrem geöffneten Notizbuch eine Compute-Instanz, falls Sie noch keine besitzen.

    Screenshot shows how to create a compute instance.

  2. Wenn die Compute-Instanz beendet wurde, wählen Sie Compute starten aus, und warten Sie, bis sie ausgeführt wird.

    Screenshot shows how to start compute if it is stopped.

  3. Stellen Sie sicher, dass der Kernel rechts oben Python 3.10 - SDK v2 ist. Falls nicht, wählen Sie diesen Kernel in der Dropdownliste aus.

    Screenshot shows how to set the kernel.

  4. Wenn Sie ein Banner mit dem Hinweis sehen, dass Sie authentifiziert werden müssen, wählen Sie Authentifizieren aus.

Wichtig

Der Rest dieses Tutorials enthält Zellen des Tutorial-Notebooks. Kopieren Sie in Ihr neues Notebook, und fügen Sie es ein, oder wechseln Sie jetzt zum Notebook, falls 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:

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

Screenshot: find the credentials for your code in the upper right of the toolbar. 

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 der 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 shows the refresh icon.

Konfigurieren des Befehls

Da Sie nun über ein Skript, das die gewünschten Aufgaben ausführen kann, und über ein Computecluster verfügen, der das Skript ausführt, verwenden Sie den 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. Sie werden hier eine dieser Umgebungen verwenden. In Tutorial: Trainieren eines Modells in Azure Machine Learning erfahren Sie, 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 Rechenressource angegeben wurde, wird das Skript auf einem serverlosen Rechencluster 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-sklearn-1.0-ubuntu20.04-py38-cpu@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 für 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. Erkunden Sie die Registerkarten, um verschiedene Details wie Metriken, Ausgaben usw. anzuzeigen. Nach dem Abschluss registriert der Auftrag ein Modell in Ihrem Arbeitsbereich als Ergebnis des Trainings.

Screenshot shows the overview page for the job.

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 werden Sie mithilfe von UUID einen eindeutigen Namen erstellen.

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 einzige Bereitstellung, die 100 % des eingehenden Datenverkehrs verarbeitet. Wir verwenden einen Farbnamen für die Bereitstellung, z. B. blue, green, red, dieser sind willkürlich gewählt.

Sie können die Seite Modelle im Azure Machine Learning Studio aufrufen, um die aktuelle Version Ihres registrierten Modells zu ermitteln. Alternativ dazu können Sie mit dem nachstehenden Code die aktuelle Versionsnummer abrufen.

# 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:

  1. Wählen Sie im Studio im linken Navigationsbereich Compute aus.
  2. Wählen Sie auf den oberen Registerkarten Compute-Instanzen aus.
  3. Wählen Sie in der Liste die Compute-Instanz aus.
  4. 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:

  1. Wählen Sie ganz links im Azure-Portal Ressourcengruppen aus.

  2. Wählen Sie in der Liste die Ressourcengruppe aus, die Sie erstellt haben.

  3. Wählen Sie die Option Ressourcengruppe löschen.

    Screenshot of the selections to delete a resource group in the Azure portal.

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