Erstellen und Ausführen von Machine Learning-Pipelines mit Komponenten und dem Azure Machine Learning SDK v2

  • Artikel

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

In diesem Artikel erfahren Sie, wie Sie mithilfe des Python SDK v2 eine Azure Machine Learning-Pipeline erstellen, um eine Bildklassifizierungsaufgabe durchzuführen, die aus drei Schritten besteht: Aufbereiten von Daten, Trainieren eines Bildklassifizierungsmodells und Bewerten des Modells mit einem Score. Machine Learning-Pipelines optimieren Ihren Workflow durch eine Verbesserung in den Bereichen Geschwindigkeit, Portabilität und Wiederverwendung, sodass Sie sich auf Machine Learning konzentrieren können, anstatt sich um Infrastruktur und Automatisierung kümmern zu müssen.

Im Beispiel wird ein kleines Convolutional Neural Network von Keras trainiert, um Bilder im Fashion MNIST-Dataset zu klassifizieren. Die Pipeline sieht wie folgt aus.

Screenshot mit Pipelinegraphen des Keras-Beispiels zur Bildklassifizierung.

In diesem Artikel führen Sie die folgenden Aufgaben aus:

  • Aufbereiten von Eingabedaten für den Pipelineauftrag
  • Erstellen von drei Komponenten zum Aufbereiten der Daten, zum Trainieren und zum Bewerten mit einem Score
  • Zusammenstellen einer Pipeline aus den Komponenten
  • Anfordern von Zugriff auf den Arbeitsbereich mit einer Computeressource
  • Übermitteln des Pipelineauftrags
  • Überprüfen der Ausgabe der Komponenten und des trainierten neuronalen Netzes
  • (Optional) Registrieren der Komponente für die weitere Wiederverwendung und die Freigabe innerhalb des Arbeitsbereichs

Wenn Sie nicht über ein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen. Probieren Sie die kostenlose oder kostenpflichtige Version von Azure Machine Learning noch heute aus.

Voraussetzungen

  • Azure Machine Learning-Arbeitsbereich – wenn Sie keinen besitzen, absolvieren Sie das Tutorial zur Ressourcenerstellung.

  • Eine Python-Umgebung, in der Sie Azure Machine Learning Python SDK v2 installiert haben. Installationsanweisungen: Sehen Sie sich den Abschnitt „Erste Schritte“ an. Diese Umgebung dient zum Definieren und Steuern Ihrer Azure Machine Learning-Ressourcen und sie ist von der Umgebung getrennt, die zur Laufzeit für das Training verwendet wird.

  • Repository für Klonbeispiele

    Klonen Sie zum Ausführen der Trainingsbeispiele zunächst das Beispielerepository, und wechseln Sie in das sdk-Verzeichnis:

    git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk

Starten einer interaktiven Python-Sitzung

In diesem Artikel wird das Python SDK für Azure Machine Learning zum Erstellen und Steuern einer Azure Machine Learning-Pipeline verwendet. In diesem Artikel wird davon ausgegangen, dass Sie die Codeausschnitte interaktiv in einer Python-REPL-Umgebung oder in einem Jupyter Notebook ausführen.

Dieser Artikel basiert auf dem Notebook image_classification_keras_minist_convnet.ipynb im Verzeichnis sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet des Repositorys mit Azure Machine Learning-Beispielen.

Importieren der erforderlichen Bibliotheken

Importieren Sie alle erforderlichen Azure Machine Learning-Bibliotheken, die Sie für diesen Artikel benötigen:

# import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

from azure.ai.ml import MLClient
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

Aufbereiten von Eingabedaten für Ihren Pipelineauftrag

Sie müssen die Eingabedaten für diese Bildklassifizierungspipeline aufbereiten.

Fashion-MNIST ist ein Dataset mit Modebildern, das in 10 Klassen unterteilt ist. Jedes Bild ist ein Graustufenbild im Format 28 x 28 und es gibt 60.000 Trainings- und 10.000 Testbilder. Als Bildklassifizierungsproblem ist Fashion-MNIST schwieriger als die klassische MNIST-Datenbank für handschriftliche Ziffern. Sie wird in der gleichen komprimierten binären Form wie die ursprüngliche Datenbank für handschriftliche Ziffern verteilt.

Importieren Sie alle erforderlichen Azure Machine Learning-Bibliotheken, die Sie benötigen.

Durch Definieren eines Input-Objekts erstellen Sie einen Verweis auf den Speicherort der Datenquelle. Die Daten verbleiben an ihrem Speicherort, sodass keine zusätzlichen Speicherkosten anfallen.

Erstellen von Komponenten für das Erstellen von Pipelines

Die Bildklassifizierungsaufgabe kann in drei Schritte unterteilt werden: Aufbereiten von Daten, Trainieren des Modells und Bewerten des Modells mit einem Score.

Eine Azure Machine Learning-Komponente ist ein eigenständiger Code, der einen Schritt in einer Machine Learning-Pipeline übernimmt. In diesem Artikel erstellen Sie drei Komponenten für die Bildklassifizierungsaufgabe:

  • Aufbereiten von Daten zum Trainieren und Testen
  • Trainieren eines neuronalen Netzes für die Bildklassifizierung mithilfe von Trainingsdaten
  • Bewerten des Modells anhand von Testdaten

Für jede Komponente müssen Sie folgende Vorbereitungen treffen:

  1. Vorbereiten des Python-Skripts mit der Ausführungslogik

  2. Definieren der Schnittstelle der Komponente

  3. Hinzufügen weiterer Metadaten der Komponente, beispielsweise Laufzeitumgebung oder Befehl zum Ausführen der Komponente

Im nächsten Abschnitt werden Komponenten auf zwei verschiedene Weisen erstellt: die ersten beiden Komponenten über die Python-Funktion und die dritte Komponente über die YAML-Definition.

Erstellen der Datenaufbereitungskomponente

Die erste Komponente in dieser Pipeline konvertiert die komprimierten Datendateien von fashion_ds in zwei CSV-Dateien: eine zum Trainieren und die andere zum Bewerten. Sie verwenden die Python-Funktion, um diese Komponente zu definieren.

Wenn Sie das Tutorial anhand des Beispiels im Repository mit Azure Machine Learning-Beispielen durcharbeiten, ist die Quelldatei bereits im Ordner prep/ verfügbar. Dieser Ordner enthält zwei Dateien zum Erstellen der Komponente: prep_component.py zur Definition der Komponente und conda.yaml zur Definition der Laufzeitumgebung der Komponente.

Definieren einer Komponente mithilfe der Python-Funktion

Mit der Funktion command_component() als Decorator können Sie die Schnittstelle, die Metadaten und den auszuführenden Code der Komponente ganz einfach über eine Python-Funktion definieren. Jede dekorierte Python-Funktion wird in eine einzelne statische Spezifikation (YAML) umgewandelt, die vom Pipelinedienst verarbeitet werden kann.

# Converts MNIST-formatted files at the passed-in input path to training data output path and test data output path
import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="prep_data",
    version="1",
    display_name="Prep Data",
    description="Convert data to CSV file, and split to training and test data",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def prepare_data_component(
    input_data: Input(type="uri_folder"),
    training_data: Output(type="uri_folder"),
    test_data: Output(type="uri_folder"),
):
    convert(
        os.path.join(input_data, "train-images-idx3-ubyte"),
        os.path.join(input_data, "train-labels-idx1-ubyte"),
        os.path.join(training_data, "mnist_train.csv"),
        60000,
    )
    convert(
        os.path.join(input_data, "t10k-images-idx3-ubyte"),
        os.path.join(input_data, "t10k-labels-idx1-ubyte"),
        os.path.join(test_data, "mnist_test.csv"),
        10000,
    )


def convert(imgf, labelf, outf, n):
    f = open(imgf, "rb")
    l = open(labelf, "rb")
    o = open(outf, "w")

    f.read(16)
    l.read(8)
    images = []

    for i in range(n):
        image = [ord(l.read(1))]
        for j in range(28 * 28):
            image.append(ord(f.read(1)))
        images.append(image)

    for image in images:
        o.write(",".join(str(pix) for pix in image) + "\n")
    f.close()
    o.close()
    l.close()

Der obige Code definiert eine Komponente mit dem Anzeigenamen Prep Data mithilfe des Decorators @command_component:

  • name ist der eindeutige Bezeichner der Komponente.

  • version ist die aktuelle Version der Komponente. Eine Komponente kann mehrere Versionen aufweisen.

  • display_name ist ein nicht eindeutiger Anzeigename der Komponente in der Benutzeroberfläche.

  • description beschreibt in der Regel, welche Aufgabe diese Komponente durchführen kann.

  • environment gibt die Laufzeitumgebung für diese Komponente an. Die Umgebung dieser Komponente gibt ein Docker-Image an und verweist auf die conda.yaml-Datei.

    Die Datei conda.yaml enthält alle Pakete, die für die Komponente verwendet werden:

    name: imagekeras_prep_conda_env
channels:
  - defaults
dependencies:
  - python=3.7.11
  - pip=20.0
  - pip:
    - mldesigner==0.1.0b4

  • Die Funktion prepare_data_component definiert eine Eingabe für input_data und zwei Ausgaben für training_data und test_data. input_data ist der Eingabedatenpfad. training_data und test_data sind Ausgabedatenpfade für Trainingsdaten und Testdaten.

  • Diese Komponente konvertiert die Daten aus input_data in eine CSV-Datei mit Trainingsdaten, training_data, und eine CSV-Datei mit Testdaten, test_data.

Nachfolgend sehen Sie, wie eine Komponente in der Studio-Benutzeroberfläche aussieht.

  • Eine Komponente ist ein Block in einem Pipelinegraphen.
  • input_data, training_data und test_data sind Ports der Komponente, die eine Verbindung mit anderen Komponenten für das Datenstreaming herstellen.

Screenshot der Komponente für die Datenvorbereitung auf der Benutzeroberfläche und im Code.

Jetzt haben Sie alle Quelldateien für die Prep Data-Komponente vorbereitet.

Erstellen der Komponente zum Trainieren des Modells

In diesem Abschnitt erstellen Sie eine Komponente zum Trainieren des Bildklassifizierungsmodells in der Python-Funktion in ähnlicher Weise wie die Prep Data-Komponente.

Der Unterschied besteht darin, dass die Trainingslogik komplizierter ist und Sie daher den ursprünglichen Trainingscode in eine separate Python-Datei einfügen können.

Die Quelldateien dieser Komponente befinden sich im Ordner train/ im Repository mit Azure Machine Learning-Beispielen. Dieser Ordner enthält drei Dateien zum Erstellen der Komponente:

  • train.py: Enthält die eigentliche Logik zum Trainieren des Modells.
  • train_component.py: Definiert die Schnittstelle der Komponente und importiert die Funktion in train.py.
  • conda.yaml: Definiert die Laufzeitumgebung der Komponente.

Abrufen eines Skripts mit Ausführungslogik

Die Datei train.py enthält eine normale Python-Funktion, die die Trainingsmodelllogik ausführt, um ein neuronales Keras-Netz für die Bildklassifizierung zu trainieren. Den Code finden Sie in der train.py-Datei auf GitHub.

Definieren einer Komponente mithilfe der Python-Funktion

Nachdem Sie die Trainingsfunktion definiert haben, können Sie @command_component im Azure Machine Learning SDK v2 verwenden, um Ihre Funktion in eine Komponente zu kapseln, die in Azure Machine Learning-Pipelines verwendet werden kann.

import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="train_image_classification_keras",
    version="1",
    display_name="Train Image Classification Keras",
    description="train image classification with keras",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def keras_train_component(
    input_data: Input(type="uri_folder"),
    output_model: Output(type="uri_folder"),
    epochs=10,
):
    # avoid dependency issue, execution logic is in train() func in train.py file
    from train import train

    train(input_data, output_model, epochs)

Der obige Code definiert eine Komponente mit dem Anzeigenamen Train Image Classification Keras mithilfe von @command_component:

  • Die Funktion keras_train_component definiert eine Eingabe input_data, aus der Trainingsdaten stammen, eine Eingabe epochs, die Epochen während des Trainings angibt, und eine Ausgabe output_model, in der die Modelldatei ausgegeben wird. Der Standardwert von epochs ist 10. Die Ausführungslogik dieser Komponente stammt aus der Funktion train() in der oben genannten Datei train.py.

Die Trainingsmodellkomponente (train-model) verfügt über eine etwas komplexere Konfiguration als die Datenaufbereitungskomponente (prep-data). conda.yaml lautet wie folgt:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.7.11
  - pip=20.2
  - pip:
    - mldesigner==0.1.0b12
    - azureml-mlflow==1.50.0
    - tensorflow==2.7.0
    - numpy==1.21.4
    - scikit-learn==1.0.1
    - pandas==1.3.4
    - matplotlib==3.2.2
    - protobuf==3.20.0

Jetzt haben Sie alle Quelldateien für die Train Image Classification Keras-Komponente vorbereitet.

Erstellen der Scoremodellkomponente

In diesem Abschnitt erstellen Sie neben den vorherigen Komponenten eine Komponente, um das trainierte Modell über die YAML-Spezifikation und ein Skript mit einem Score zu bewerten.

Wenn Sie das Tutorial anhand des Beispiels im Repository mit Azure Machine Learning-Beispielen durcharbeiten, ist die Quelldatei bereits im Ordner score/ verfügbar. Dieser Ordner enthält drei Dateien zum Erstellen der Komponente:

  • score.py: Enthält den Quellcode der Komponente.
  • score.yaml: Definiert die Schnittstelle und andere Details der Komponente.
  • conda.yaml: Definiert die Laufzeitumgebung der Komponente.

Abrufen eines Skripts mit Ausführungslogik

Die Datei score.py enthält eine normale Python-Funktion, die die Trainingsmodelllogik ausführt.

from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import to_categorical
from keras.callbacks import Callback
from keras.models import load_model

import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import mlflow


def get_file(f):

    f = Path(f)
    if f.is_file():
        return f
    else:
        files = list(f.iterdir())
        if len(files) == 1:
            return files[0]
        else:
            raise Exception("********This path contains more than one file*******")


def parse_args():
    # setup argparse
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument(
        "--input_data", type=str, help="path containing data for scoring"
    )
    parser.add_argument(
        "--input_model", type=str, default="./", help="input path for model"
    )

    parser.add_argument(
        "--output_result", type=str, default="./", help="output path for model"
    )

    # parse args
    args = parser.parse_args()

    # return args
    return args


def score(input_data, input_model, output_result):

    test_file = get_file(input_data)
    data_test = pd.read_csv(test_file, header=None)

    img_rows, img_cols = 28, 28
    input_shape = (img_rows, img_cols, 1)

    # Read test data
    X_test = np.array(data_test.iloc[:, 1:])
    y_test = to_categorical(np.array(data_test.iloc[:, 0]))
    X_test = (
        X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
    )

    # Load model
    files = [f for f in os.listdir(input_model) if f.endswith(".h5")]
    model = load_model(input_model + "/" + files[0])

    # Log metrics of the model
    eval = model.evaluate(X_test, y_test, verbose=0)

    mlflow.log_metric("Final test loss", eval[0])
    print("Test loss:", eval[0])

    mlflow.log_metric("Final test accuracy", eval[1])
    print("Test accuracy:", eval[1])

    # Score model using test data
    y_predict = model.predict(X_test)
    y_result = np.argmax(y_predict, axis=1)

    # Output result
    np.savetxt(output_result + "/predict_result.csv", y_result, delimiter=",")


def main(args):
    score(args.input_data, args.input_model, args.output_result)


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # call main function
    main(args)

Der Code in „score.py“ verwendet drei Befehlszeilenargumente: input_data, input_model und output_result. Das Programm bewertet das Eingabemodell anhand von Eingabedaten und gibt dann den Score aus.

Definieren der Komponente über YAML

In diesem Abschnitt erfahren Sie, wie Sie eine Komponentenspezifikation im gültigen Format für YAML-Komponentenspezifikationen erstellen. Diese Datei gibt folgende Informationen an:

  • Metadaten: Name, Anzeigename, Version, Typ usw.
  • Schnittstelle: Ein- und Ausgaben
  • Befehl, Code und Umgebung: Der Befehl, der Code und die Umgebung zum Ausführen der Komponente
$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: score_image_classification_keras
display_name: Score Image Classification Keras
inputs:
  input_data: 
    type: uri_folder
  input_model:
    type: uri_folder
outputs:
  output_result:
    type: uri_folder
code: ./
command: python score.py --input_data ${{inputs.input_data}} --input_model ${{inputs.input_model}} --output_result ${{outputs.output_result}}
environment:
  conda_file: ./conda.yaml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04
  • name ist der eindeutige Bezeichner der Komponente. Der Anzeigename lautet Score Image Classification Keras.
  • Diese Komponente verfügt über zwei Eingaben und eine Ausgabe.
  • Der Quellcodepfad der Komponente wird im Abschnitt code definiert. Wenn die Komponente in der Cloud ausgeführt wird, werden alle Dateien aus diesem Pfad als Momentaufnahme dieser Komponente hochgeladen.
  • Der Abschnitt command gibt den Befehl an, der beim Ausführen dieser Komponente ausgeführt werden soll.
  • Der Abschnitt environment enthält ein Docker-Image und eine Conda-YAML-Datei. Die Quelldatei befindet sich im Beispielrepository.

Jetzt verfügen Sie über alle Quelldateien für die Scoremodellkomponente (score-model).

Laden von Komponenten zum Erstellen der Pipeline

Die Komponente „prep-data“ und die Komponente „train-model“, die durch eine Python-Funktion definiert sind, können wie normale Python-Funktionen importiert werden.

Im folgenden Code importieren Sie die prepare_data_component()- und die keras_train_component()-Funktion aus der Datei prep_component.py im Ordner prep und aus der Datei train_component im Ordner train.

%load_ext autoreload
%autoreload 2

# load component function from component python file
from prep.prep_component import prepare_data_component
from train.train_component import keras_train_component

# print hint of components
help(prepare_data_component)
help(keras_train_component)

Für die durch YAML definierte Scorekomponente können Sie zum Laden die Funktion load_component() verwenden.

# load component function from yaml
keras_score_component = load_component(source="./score/score.yaml")

Erstellen Ihrer Pipeline

Nachdem Sie alle notwendigen Komponenten und Eingabedaten für eine Pipeline erstellt und geladen haben, können Sie sie in einer Pipeline zusammensetzen:

Hinweis

Um serverloses Computing zu verwenden, fügen Sie from azure.ai.ml.entities import ResourceConfiguration an den Anfang. Ersetzen Sie dann Folgendes:

  • default_compute=cpu_compute_target, mit default_compute="serverless",
  • train_node.compute = gpu_compute_target mit train_node.resources = "ResourceConfiguration(instance_type="Standard_NC6s_v3",instance_count=2)
# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=mnist_ds)

Die Pipeline verfügt über eine Standardcomputeressource cpu_compute_target. Wenn Sie für einen bestimmten Knoten keine Computeressource angeben, wird dieser Knoten auf der Standardcomputeressource ausgeführt.

Die Pipeline verfügt über eine Eingabe auf Pipelineebene, pipeline_input_data. Sie können der Pipelineeingabe einen Wert zuweisen, wenn Sie einen Pipelineauftrag übermitteln.

Die Pipeline enthält drei Knoten: „prepare_data_node“, „train_node“ und „score_node“.

  • input_data von prepare_data_node verwendet den Wert von pipeline_input_data.

  • input_data von train_node stammt aus der training_data-Ausgabe von „prepare_data_node“.

  • input_data von „score_node“ stammt aus der test_data-Ausgabe von „prepare_data_node“, und input_model stammt aus output_model von „train_node“.

  • Da train_node ein CNN-Modell trainiert, können Sie die zugehörige Computeressource als „gpu_compute_target“ angeben, um die Trainingsleistung zu verbessern.

Senden Ihres Pipelineauftrags

Jetzt haben Sie die Pipeline erstellt und können sie an Ihren Arbeitsbereich übermitteln. Um einen Auftrag zu übermitteln, müssen Sie zunächst eine Verbindung mit einem Arbeitsbereich herstellen.

Erteilen von Zugriff auf Ihren Arbeitsbereich

Konfigurieren von Anmeldeinformationen

Wir verwenden DefaultAzureCredential, um Zugriff auf den Arbeitsbereich zu erhalten. DefaultAzureCredential sollte die meisten Azure SDK-Authentifizierungsszenarien abdecken können.

Falls dies für Sie nicht funktioniert, finden Sie hier weitere verfügbare Anmeldeinformationen zur Referenz: Beispiel zum Konfigurieren von Anmeldeinformationen, Referenzdokument zu azure-identity.

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

Abrufen eines Handles für einen Arbeitsbereich mit Computeressource

Erstellen Sie ein MLClient-Objekt, um Azure Machine Learning-Dienste zu verwalten. Wenn Sie serverloses Computing verwenden, müssen Sie diese Computeressourcen nicht erstellen.

# Get a handle to workspace
ml_client = MLClient.from_config(credential=credential)

# Retrieve an already attached Azure Machine Learning Compute.
cpu_compute_target = "cpu-cluster"
print(ml_client.compute.get(cpu_compute_target))
gpu_compute_target = "gpu-cluster"
print(ml_client.compute.get(gpu_compute_target))

Wichtig

In diesem Codeausschnitt wird davon ausgegangen, dass die JSON-Datei mit der Arbeitsbereichskonfiguration im aktuellen Verzeichnis oder im übergeordneten Verzeichnis gespeichert ist. Weitere Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen von Arbeitsbereichressourcen. Weitere Informationen zum Speichern der Konfiguration in einer Datei finden Sie unter Konfigurieren einer Entwicklungsumgebung für Azure Machine Learning.

Senden des Pipelineauftrags an den Arbeitsbereich

Sobald Sie über ein Handle für Ihren Arbeitsbereich verfügen, können Sie Ihren Pipelineauftrag übermitteln.

pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="pipeline_samples"
)
pipeline_job

Der oben genannte Code sendet diesen Auftrag für die Bildklassifizierung an ein Experiment namens pipeline_samples. Das Experiment wird automatisch erstellt, wenn es nicht vorhanden ist. pipeline_input_data verwendet fashion_ds.

Der Aufruf von pipeline_job erzeugt ungefähr folgende Ausgabe:

Durch den Aufruf von submit wird Experiment schnell abgeschlossen und erzeugt eine Ausgabe ähnlich der folgenden:

Experiment Name Typ Status Details Page
pipeline_samples sharp_pipe_4gvqx6h1fb pipeline Wird vorbereitet Link zu Azure Machine Learning Studio.

Sie können die Pipelineausführung überwachen, indem Sie den Link öffnen, oder Sie können die Ausführung bis zum Abschluss blockieren, indem Sie Folgendes ausführen:

# wait until the job completes
ml_client.jobs.stream(pipeline_job.name)

Wichtig

Die erste Pipelineausführung dauert ungefähr 15 Minuten. Alle Abhängigkeiten müssen heruntergeladen werden, ein Docker-Image wird erstellt, und die Python-Umgebung wird bereitgestellt und erstellt. Die erneute Ausführung der Pipeline ist dagegen deutlich schneller, da diese Ressourcen wiederverwendet und nicht neu erstellt werden. Die Gesamtlaufzeit der Pipeline hängt jedoch von der Arbeitsauslastung Ihrer Skripts sowie von den Prozessen ab, die in den einzelnen Pipelineschritten ausgeführt werden.

Auschecken der Ausgabe und Debuggen der Pipeline in der Benutzeroberfläche

Sie können Link to Azure Machine Learning studio öffnen. Hierbei handelt es sich um die Auftragsdetailseite Ihrer Pipeline. Der Pipelinegraph wird wie folgt angezeigt.

Screenshot der Detailseite des Pipelineauftrags.

Sie können die Protokolle und Ausgabe der einzelnen Komponenten überprüfen, indem Sie mit der rechten Maustaste auf die Komponente klicken oder die Komponente auswählen, um den Detailbereich zu öffnen. Weitere Informationen zum Debuggen Ihrer Pipeline in der Benutzeroberfläche finden Sie unter Debuggen von Pipeline-Ausfällen.

(Optional) Registrieren von Komponenten beim Arbeitsbereich

Im vorherigen Abschnitt haben Sie eine Pipeline mit drei Komponenten erstellt, um eine vollständige Bildklassifizierungsaufgabe durchzuführen. Sie können auch Komponenten bei Ihrem Arbeitsbereich registrieren, damit sie innerhalb des Arbeitsbereichs freigegeben und erneut ausgeführt werden können. Nachfolgend sehen Sie ein Beispiel zum Registrieren der Komponente „prep-data“.

try:
    # try get back the component
    prep = ml_client.components.get(name="prep_data", version="1")
except:
    # if not exists, register component using following code
    prep = ml_client.components.create_or_update(prepare_data_component)

# list all components registered in workspace
for c in ml_client.components.list():
    print(c)

Mithilfe von ml_client.components.get() können Sie eine registrierte Komponente anhand ihres Namens und der Version abrufen. Mithilfe von ml_client.components.create_or_update() können Sie eine zuvor über eine Python-Funktion oder YAML geladene Komponente registrieren.

Nächste Schritte