Tutorial: Erstellen von Produktions-ML-Pipelines mit dem Python SDK v2 in einem Jupyter Notebook

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

Hinweis

Ein Tutorial, das SDK v1 zum Erstellen einer Pipeline verwendet, finden Sie unter Tutorial: Erstellen einer Azure Machine Learning Pipeline für die Bildklassifizierung.

In diesem Tutorial verwenden Sie Azure Machine Learning, um ein produktionsreifes Machine Learning-Projekt zu erstellen. Dazu verwenden Sie das Azure Machine Learning Python SDK v2.

Sie erfahren, wie Sie das Azure Machine Learning Python SDK v2 für Folgendes verwenden:

• Herstellen einer Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich
• Erstellen von Azure Machine Learning-Datenressourcen
• Erstellen wiederverwendbarer Azure Machine Learning-Komponenten
• Erstellen, Validieren und Ausführen von Azure Machine Learning-Pipelines
• Bereitstellen des neu trainierten Modells als Endpunkt
• Aufrufen des Azure Machine Learning-Endpunkts für Rückschlüsse

Voraussetzungen

• Arbeiten Sie Schnellstart: Erste Schritte mit Azure Machine Learning durch, um Folgendes durchzuführen:
  • Erstellen eines Arbeitsbereichs.
  • Erstellen einer cloudbasierten Compute-Instanz, die für Ihre Entwicklungsumgebung verwendet werden soll
  • Erstellen eines cloudbasierten Computeclusters, der für das Training Ihres Modells verwendet werden soll
• Schließen Sie den Schnellstart: Ausführen von Jupyter Notebooks im Studio ab, um den Ordner SDK v2/tutorials zu klonen.

Öffnen des Notebooks

1. Öffnen Sie den Ordner Tutorials, den Sie im Schnellstart in den Abschnitt Dateien geklont haben: Schnellstart: Ausführen von Jupyter Notebooks im Studio.

2. Wählen Sie in Ihrem Ordner tutorials/azureml-examples/tutorials/e2e-ds-experience/ die Datei e2e-ml-workflow.ipynb aus.

   

3. Wählen Sie in der oberen Leiste die Compute-Instanz aus, die Sie während des Schnellstarts: Erste Schritte mit Azure Machine Learning erstellt haben, um sie zum Ausführen des Notebooks zu verwenden.

Wichtig

Der Rest dieses Artikels enthält denselben Inhalt, den Sie auch im Notebook sehen.

Wechseln Sie jetzt zum Jupyter Notebook, wenn Sie den Code beim Weiterlesen ausführen möchten. Klicken Sie zum Ausführen einer einzelnen Codezelle in einem Notebook auf die gewünschte Codezelle, und drücken Sie UMSCHALT+EINGABE. Sie können auch das gesamte Notebook ausführen, indem Sie in der oberen Symbolleiste Alle ausführen auswählen.

Einführung

In diesem Tutorial erstellen Sie eine Azure Machine Learning-Pipeline, um ein Modell für die Kreditausfallvorhersage zu trainieren. Die Pipeline übernimmt die Datenaufbereitung, das Training und die Registrierung des trainierten Modells. Anschließend führen Sie die Pipeline aus, stellen das Modell bereit und verwenden es.

Die folgende Abbildung zeigt die Pipeline so, wie sie nach der Übermittlung im Azure Machine Learning-Portal angezeigt wird. Es handelt sich um eine recht einfache Pipeline, mit der Sie durch die Arbeit mit dem Azure Machine Learning SDK v2 geleitet werden.

Die beiden ersten Schritte sind die Datenaufbereitung und das Training.

Einrichten der Pipelineressourcen

Das Azure Machine Learning-Framework kann über die CLI, das Python SDK oder die Studio-Schnittstelle verwendet werden. In diesem Beispiel verwenden Sie das Azure Machine Learning Python SDK v2 zum Erstellen einer Pipeline.

Bevor Sie die Pipeline erstellen, richten Sie die Ressourcen ein, die die Pipeline verwenden soll:

• Die Datenressource für das Training
• Die Softwareumgebung zum Ausführen der Pipeline
• Eine Computeressource für die Ausführung des Auftrags

Herstellen einer Verbindung mit dem Arbeitsbereich

Bevor wir uns dem Code zuwenden, müssen Sie eine Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich herstellen. 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.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

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

1. Wählen Sie auf der oben rechts angezeigten Azure Machine Learning Studio-Symbolleiste den Namen Ihres Arbeitsbereichs aus.
2. Sie sehen die Werte, die Sie für <SUBSCRIPTION_ID>, <RESOURCE_GROUP> und <AML_WORKSPACE_NAME> benötigen.
3. Kopieren Sie einen Wert, schließen Sie das Fenster und fügen Sie ihn in Ihren Code ein. Öffnen Sie das Tool erneut, um den nächsten Wert zu erhalten.

# 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 Ergebnis ist ein Handler für den Arbeitsbereich, den Sie für die Verwaltung anderer Ressourcen und Aufträge verwenden.

Wichtig

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 (im nachstehenden Notebook ist dies während der Datasetregistrierung der Fall).

Registrieren von Daten über eine externe URL

Die für das Training verwendeten Daten befinden sich normalerweise an einem der folgenden Orte:

• Lokaler Computer
• Web
• Big Data-Speicherdienste (z. B. Azure Blob, Azure Data Lake Storage, SQL)

Azure Machine Learning verwendet ein Data-Objekt, um eine wiederverwendbare Datendefinition zu registrieren und Daten innerhalb einer Pipeline zu nutzen. Im folgenden Abschnitt nutzen Sie beispielsweise einige Daten aus einer Web-URL. Es können auch Daten aus anderen Quellen erstellt werden. Data-Ressourcen aus anderen Quellen können ebenfalls erstellt werden.

from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes

web_path = "https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls"

credit_data = Data(
    name="creditcard_defaults",
    path=web_path,
    type=AssetTypes.URI_FILE,
    description="Dataset for credit card defaults",
    tags={"source_type": "web", "source": "UCI ML Repo"},
    version="1.0.0",
)

Mit diesem Code wurde soeben eine Data-Ressource erstellt. Diese kann von der Pipeline, die Sie in den nächsten Abschnitten definieren, als Eingabe verwendet werden. Darüber hinaus können Sie die Daten bei Ihrem Arbeitsbereich registrieren, damit sie in verschiedenen Pipelines wiederverwendet werden können.

Die Registrierung der Datenressource ermöglicht Folgendes:

• Wiederverwenden und Freigeben der Datenressource in zukünftigen Pipelines
• Verwenden von Versionen zum Nachverfolgen von Änderungen an der Datenressource
• Verwenden des Datenobjekts aus dem Azure Machine Learning-Designer, der grafischen Benutzeroberfläche von Azure Machine Learning für die Erstellung von Pipelines

Da Sie den Arbeitsbereich zum ersten Mal aufrufen, werden Sie möglicherweise aufgefordert, sich zu authentifizieren. Sobald die Authentifizierung durchgeführt wurde, werden Sie in einer Meldung über den Abschluss der Datasetregistrierung informiert.

credit_data = ml_client.data.create_or_update(credit_data)
print(
    f"Dataset with name {credit_data.name} was registered to workspace, the dataset version is {credit_data.version}"
)

Künftig können Sie dieses Dataset mithilfe von credit_dataset = ml_client.data.get("<DATA ASSET NAME>", version='<VERSION>') aus dem Arbeitsbereich abrufen.

Erstellen einer Computeressource zum Ausführen der Pipeline

Jeder Schritt einer Azure Machine Learning-Pipeline kann eine andere Computeressource für die Ausführung des spezifischen Auftrags in diesem Schritt verwenden. Dabei kann es sich um Computer mit einem oder mehreren Knoten mit Linux- oder Windows-Betriebssystemen oder um ein spezielles Computefabric wie Spark handeln.

In diesem Abschnitt stellen Sie einen Linux-Computecluster bereit. Sehen Sie sich die vollständige Liste der VM-Größen und -Preise an.

Für dieses Tutorial benötigen Sie nur einen einfachen Cluster. Also verwenden wir ein Standard_DS3_v2-Modell mit 2 vCPU-Kernen und 7 GB RAM und erstellen eine Azure Machine Learning-Computeressource.

Tipp

Wenn Sie bereits einen Computecluster haben, ersetzen Sie „cpu-cluster“ im Code unten durch den Namen Ihres Clusters. Dies hindert Sie daran, einen weiteren zu erstellen.

from azure.ai.ml.entities import AmlCompute

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 assigned to the compute cluster
        name="cpu-cluster",
        # 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.begin_create_or_update(cpu_cluster)

print(
    f"AMLCompute with name {cpu_cluster.name} is created, the compute size is {cpu_cluster.size}"
)

Erstellen einer Auftragsumgebung für Pipelineschritte

Bis zu diesem Zeitpunkt haben Sie eine Entwicklungsumgebung auf der Compute-Instance, Ihrem Entwicklungsrechner, erstellt. Sie benötigen außerdem eine Umgebung, die Sie für die einzelnen Pipelineschritte verwenden können. Jeder Schritt kann über eine eigene Umgebung verfügen, oder Sie können einige gemeinsame Umgebungen für mehrere Schritte verwenden.

In diesem Beispiel erstellen Sie eine Conda-Umgebung für Ihre Aufträge, indem Sie eine Conda-YAML-Datei verwenden. Zunächst erstellen Sie ein Verzeichnis, in dem die Datei gespeichert wird.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Jetzt erstellen Sie die Datei im Abhängigkeitsverzeichnis.

%%writefile {dependencies_dir}/conda.yml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 1.26.1
    - azureml-mlflow==1.42.0

Die Spezifikation enthält einige übliche Pakete, die Sie in Ihrer Pipeline verwenden werden (numpy, pip), zusammen mit einigen Azure Machine Learning-spezifischen Paketen (azureml-defaults, azureml-mlflow).

Die Azure Machine Learning-Pakete sind für die Ausführung von Azure Machine Learning-Aufträgen nicht zwingend erforderlich. Durch das Hinzufügen dieser Pakete können Sie jedoch mit Azure Machine Learning interagieren, um Metriken zu protokollieren und Modelle zu registrieren – und zwar innerhalb des Azure Machine Learning-Auftrags. Sie werden sie später in diesem Tutorial im Trainingsskript verwenden.

Verwenden Sie die YAML-Datei, um diese benutzerdefinierte Umgebung in Ihrem Arbeitsbereich zu erstellen und zu registrieren:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
    version="0.1.0",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

Erstellen der Trainingspipeline

Sie verfügen jetzt über alle für die Ausführung Ihrer Pipeline erforderlichen Objekte und können die Pipeline mit dem Azure Machine Learning Python SDK v2 erstellen.

Azure Machine Learning-Pipelines sind wiederverwendbare ML-Workflows, die normalerweise aus mehreren Komponenten bestehen. Der typische Lebenszyklus einer Komponente lautet wie folgt:

• Die YAML-Spezifikation der Komponente wird geschrieben oder mit ComponentMethod programmgesteuert erstellt.
• Sie können die Komponente optional mit einem Namen und einer Version für Ihren Arbeitsbereich registrieren, damit sie wiederverwendet und gemeinsam genutzt werden kann.
• Die Komponente wird über den Pipelinecode geladen.
• Die Pipeline wird unter Verwendung der Eingaben, Ausgaben und Parameter der Komponente implementiert.
• Die Pipeline wird übermittelt.

Erstellen von Komponente 1: Datenaufbereitung (anhand einer programmgesteuerten Definition)

Lassen Sie uns mit der Erstellung der ersten Komponente beginnen. Diese Komponente sorgt für die Vorverarbeitung der Daten. Die Aufgabe zur Vorverarbeitung wird in der Python-Datei data_prep.py ausgeführt.

Erstellen Sie zunächst einen Quellordner für die data_prep-Komponente:

import os

data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)

Dieses Skript übernimmt die einfache Aufgabe, die Daten in Trainings- und Testdatasets aufzuteilen. Azure Machine Learning stellt Datasets als Ordner für die Compute-Instanzen bereit. Daher haben wir die Hilfsfunktion select_first_file für den Zugriff auf die Datendatei im bereitgestellten Eingabeordner erstellt.

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

%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow


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("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)

    credit_df = pd.read_excel(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)

    credit_train_df, credit_test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )

    # output paths are mounted as folder, therefore, we are adding a filename to the path
    credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)

    credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Da Sie nun über ein Skript verfügen, das die gewünschte Aufgabe ausführen kann, erstellen Sie daraus eine Azure Machine Learning-Komponente.

Sie verwenden die universelle CommandComponent, die Befehlszeilenaktionen ausführen kann. Diese Befehlszeilenaktion kann direkt Systembefehle aufrufen oder ein Skript ausführen. Die Eingaben/Ausgaben werden mittels ${{ ... }}-Notation an der Befehlszeile angegeben.

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

data_prep_component = command(
    name="data_prep_credit_defaults",
    display_name="Data preparation for training",
    description="reads a .xl input, split the input to train and test",
    inputs={
        "data": Input(type="uri_folder"),
        "test_train_ratio": Input(type="number"),
    },
    outputs=dict(
        train_data=Output(type="uri_folder", mode="rw_mount"),
        test_data=Output(type="uri_folder", mode="rw_mount"),
    ),
    # The source folder of the component
    code=data_prep_src_dir,
    command="""python data_prep.py \
            --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
            --train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
            """,
    environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)

Optional können Sie die Komponente zur späteren Wiederverwendung im Arbeitsbereich registrieren.

Erstellen von Komponente 2: Training (mithilfe der YAML-Definition)

Die zweite Komponente, die Sie erstellen werden, erfasst die Trainings- und Testdaten, trainiert ein strukturbasiertes Modell und gibt das Ausgabemodell zurück. Sie verwenden die Protokollierungsfunktionen von Azure Machine Learning, um den Lernfortschritt aufzuzeichnen und zu visualisieren.

Sie haben Ihre erste Komponente mithilfe der CommandComponent-Klasse erstellt. Die zweite Komponente erstellen Sie mithilfe der YAML-Definition. Jede Methode hat ihre Vorzüge. Eine YAML-Definition kann im Code eingecheckt werden und würde eine lesbare Verlaufsnachverfolgung ermöglichen. Die programmgesteuerte Methode mit Verwendung von CommandComponent kann durch die integrierte Klassendokumentation und die Codevervollständigung einfacher sein.

Erstellen Sie das Verzeichnis für diese Komponente:

import os

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

Erstellen Sie das Trainingsskript im Verzeichnis:

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


def select_first_file(path):
    """Selects first file in folder, use under assumption there is only one file in folder
    Args:
        path (str): path to directory or file to choose
    Returns:
        str: full path of selected file
    """
    files = os.listdir(path)
    return os.path.join(path, files[0])


# Start Logging
mlflow.start_run()

# enable autologging
mlflow.sklearn.autolog()

os.makedirs("./outputs", exist_ok=True)


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

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    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")
    parser.add_argument("--model", type=str, help="path to model file")
    args = parser.parse_args()

    # paths are mounted as folder, therefore, we are selecting the file from folder
    train_df = pd.read_csv(select_first_file(args.train_data))

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

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

    # paths are mounted as folder, therefore, we are selecting the file from folder
    test_df = pd.read_csv(select_first_file(args.test_data))

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

    # 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.model, "trained_model"),
    )

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

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

Als Umgebung für diesen Schritt verwenden Sie eine der integrierten (kuratierten) Azure Machine Learning-Umgebungen. Das Tag azureml weist das System an, den Namen in kuratierten Umgebungen zu suchen.

Erstellen Sie zunächst die YAML-Datei, die die Komponente beschreibt:

%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
  train_data: 
    type: uri_folder
  test_data: 
    type: uri_folder
  learning_rate:
    type: number     
  registered_model_name:
    type: string
outputs:
  model:
    type: uri_folder
code: .
environment:
  # for this step, we'll use an AzureML curate environment
  azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu:1
command: >-
  python train.py 
  --train_data ${{inputs.train_data}} 
  --test_data ${{inputs.test_data}} 
  --learning_rate ${{inputs.learning_rate}}
  --registered_model_name ${{inputs.registered_model_name}} 
  --model ${{outputs.model}}
# </component>

Erstellen und registrieren Sie jetzt die Komponente:

# importing the Component Package
from azure.ai.ml import load_component

# Loading the component from the yml file
train_component = load_component(source=os.path.join(train_src_dir, "train.yml"))

# Now we register the component to the workspace
train_component = ml_client.create_or_update(train_component)

# Create (register) the component in your workspace
print(
    f"Component {train_component.name} with Version {train_component.version} is registered"
)

Erstellen der Pipeline aus Komponenten

Nun, da Ihre beiden Komponenten definiert und registriert sind, können Sie mit der Implementierung der Pipeline beginnen.

Hier verwenden Sie Eingabedaten, Aufteilungsverhältnis und registrierter Modellname als Eingabevariablen. Anschließend rufen Sie die Komponenten auf und verbinden sie über ihre Eingabe-/Ausgabebezeichner. Auf die Ausgabe für jeden Schritt kann mithilfe der .outputs-Eigenschaft zugegriffen werden.

Die von load_component() zurückgegebenen Python-Funktionen funktionieren wie jede reguläre Python-Funktion, die wir innerhalb einer Pipeline zum Aufrufen der einzelnen Schritte verwenden werden.

Um die Pipeline zu codieren, verwenden Sie einen spezifischen @dsl.pipeline-Decorator, der die Azure Machine Learning-Pipelines identifiziert. Im Decorator können wir die Pipelinebeschreibung und Standardressourcen wie Compute- und Speicherinstanzen angeben. Wie eine Python-Funktion können auch Pipelines Eingaben verwenden. Anschließend können Sie mehrere Instanzen einer einzelnen Pipeline mit unterschiedlichen Eingaben erstellen.

Hier haben wir Eingabedaten, Aufteilungsverhältnis und registrierter Modellname als Eingabevariablen verwendet. Anschließend rufen wir die Komponenten auf und verbinden sie über ihre Eingabe-/Ausgabebezeichner. Auf die Ausgabe für jeden Schritt kann mithilfe der .outputs-Eigenschaft zugegriffen werden.

# the dsl decorator tells the sdk that we are defining an Azure ML pipeline
from azure.ai.ml import dsl, Input, Output


@dsl.pipeline(
    compute=cpu_compute_target,
    description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
    pipeline_job_data_input,
    pipeline_job_test_train_ratio,
    pipeline_job_learning_rate,
    pipeline_job_registered_model_name,
):
    # using data_prep_function like a python call with its own inputs
    data_prep_job = data_prep_component(
        data=pipeline_job_data_input,
        test_train_ratio=pipeline_job_test_train_ratio,
    )

    # using train_func like a python call with its own inputs
    train_job = train_component(
        train_data=data_prep_job.outputs.train_data,  # note: using outputs from previous step
        test_data=data_prep_job.outputs.test_data,  # note: using outputs from previous step
        learning_rate=pipeline_job_learning_rate,  # note: using a pipeline input as parameter
        registered_model_name=pipeline_job_registered_model_name,
    )

    # a pipeline returns a dictionary of outputs
    # keys will code for the pipeline output identifier
    return {
        "pipeline_job_train_data": data_prep_job.outputs.train_data,
        "pipeline_job_test_data": data_prep_job.outputs.test_data,
    }

Verwenden Sie nun Ihre Pipelinedefinition, um eine Pipeline mit Ihrem Dataset, dem gewünschten Aufteilungsverhältnis und dem von Ihnen gewählten Namen für Ihr Modell zu instanziieren.

registered_model_name = "credit_defaults_model"

# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
    pipeline_job_data_input=Input(type="uri_file", path=credit_data.path),
    pipeline_job_test_train_ratio=0.25,
    pipeline_job_learning_rate=0.05,
    pipeline_job_registered_model_name=registered_model_name,
)

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

Sie übergeben auch einen Experimentnamen. Ein Experiment ist ein Container für alle Iterationen, die für ein bestimmtes Projekt ausgeführt werden. Alle mit demselben Experimentnamen übermittelten Aufträge werden nebeneinander in Azure Machine Learning Studio aufgelistet.

Nach Abschluss des Vorgangs registriert die Pipeline als Ergebnis des Trainings ein Modell in Ihrem Arbeitsbereich.

import webbrowser

# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
    pipeline,
    # Project's name
    experiment_name="e2e_registered_components",
)
# open the pipeline in web browser
webbrowser.open(pipeline_job.studio_url)

Von der obigen Zelle wird die Ausgabe FALSE erwartet. Sie können den Fortschritt Ihrer Pipeline verfolgen, indem Sie den in der obigen Zelle generierten Link verwenden.

Wenn Sie eine Komponente auswählen, werden weitere Informationen zu den Ergebnissen der jeweiligen Komponente angezeigt. Es gibt zwei wichtige Punkte, auf die Sie in dieser Phase achten sollten:

• Outputs+logs>user_logs>std_log.txt Dieser Abschnitt zeigt die Ausführung des sdtout-Skripts.

  

• Outputs+logs>Metric in diesem Abschnitt werden verschiedene protokollierte Metriken angezeigt. In diesem Beispiel Über „mlflow autologging“ wurden automatisch die Trainingsmetriken aufgezeichnet.

  

Bereitstellen des Modells als Onlineendpunkt

Stellen Sie Ihr Machine Learning-Modell nun als Webdienst in der Azure-Cloud (online endpoint) bereit. Um einen Dienst für maschinelles Lernen bereitzustellen, benötigen Sie normalerweise Folgendes:

• Die Modellressourcen (Dateien, Metadaten), die Sie bereitstellen möchten. Sie haben diese Ressourcen bereits in Ihrer Trainingskomponente registriert.
• Code, der als Dienst ausgeführt werden soll. Der Code führt das Modell für eine bestimmte Eingabeanforderung aus. Dieses Einstiegsskript empfängt Daten, die an einen bereitgestellten Webdienst übermittelt wurden, und übergibt sie an das Modell. Anschließend wird die Antwort des Modells an den Client zurückgegeben. Das Skript ist auf Ihr Modell zugeschnitten. Im Einstiegsskript muss die Struktur der vom Modell erwarteten und zurückgegebenen Daten bekannt sein. Wenn Sie wie in diesem Tutorial ein MLFlow-Modell verwenden, wird dieses Skript automatisch für Sie erstellt.

Erstellen eines neuen Onlineendpunkts

Da Sie nun über ein registriertes Modell und ein Rückschlussskript 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]

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_result = ml_client.begin_create_or_update(endpoint).result()

print(
    f"Endpint {endpoint_result.name} provisioning state: {endpoint_result.provisioning_state}"
)

Nachdem Sie einen 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

Nachdem der Endpunkt erstellt wurde, stellen Sie das Modell mit dem Einstiegsskript bereit. Jeder Endpunkt kann über mehrere Bereitstellungen verfügen, und der direkte Datenverkehr an diese Bereitstellungen kann mithilfe von Regeln festgelegt 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 in 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)]
)

Stellen Sie die aktuelle Version des Modells bereit.

Hinweis

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

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


# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
)

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

print(
    f"Deployment {blue_deployment_results.name} provisioning state: {blue_deployment_results.provisioning_state}"
)

Testen mit einer Beispielabfrage

Nachdem 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

Dieser Schritt kann ungefähr 6 bis 8 Minuten in Anspruch nehmen.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Nächste Schritte

Erfahren Sie mehr über die Azure Machine Learning-Protokollierung.