Schnellstart: Erste Schritte mit Azure Machine Learning

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:

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

Voraussetzungen

1. Für die Verwendung von Azure Machine Learning 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.

   Wichtig

   Wenn Ihr Azure Machine Learning-Arbeitsbereich mit einem verwalteten virtuellen Netzwerk konfiguriert ist, müssen Sie möglicherweise Ausgangsregeln hinzufügen, um den Zugriff auf die öffentlichen Python-Paketrepositorys zu ermöglichen. Weitere Informationen finden Sie unter Szenario: Zugreifen auf öffentliche Machine Learning-Pakete.

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:

   • 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 anhand von Beispiel-Notebooks.

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

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

   

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

   

3. Warten Sie, bis die Compute-Instanz ausgeführt wird. Vergewissern Sie sich dann, dass sich rechts oben der Kernel Python 3.10 - SDK v2 befindet. Falls nicht, verwenden Sie die Dropdownliste, um diesen Kernel auszuwählen.

   

   Falls dieser Kernel nicht angezeigt wird, überprüfen Sie, ob Ihre Compute-Instanz ausgeführt wird. Falls ja, wählen Sie rechts oben im Notebook die Schaltfläche Aktualisieren aus.

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

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

   

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.

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,
)

# 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")

    # pin numpy
    conda_env = {
        'name': 'mlflow-env',
        'channels': ['conda-forge'],
        'dependencies': [
            'python=3.10.15',
            'pip<=21.3.1',
            {
                'pip': [
                    'mlflow==2.17.0',
                    'cloudpickle==2.2.1',
                    'pandas==1.5.3',
                    'psutil==5.8.0',
                    'scikit-learn==1.5.2',
                    'numpy==1.26.4',
                ]
            }
        ],
    }

    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
        conda_env=conda_env,
    )

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

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.

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}")

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()

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.

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

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

1. Geben Sie im Azure-Portal den Suchbegriff Ressourcengruppen in das Suchfeld ein, und wählen Sie in den Ergebnissen die entsprechende Option aus.

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

3. Wählen Sie auf der Seite Übersicht die Option Ressourcengruppe löschen aus.

   

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: