Freigeben über

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

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

In diesem Artikel erfahren Sie, wie Sie eine Azure Machine Learning-Pipeline mithilfe des Azure Machine Learning Python SDK v2 erstellen, um eine Imageklassifizierungsaufgabe auszuführen, die drei Schritte enthält: Vorbereiten von Daten, Trainieren eines Imageklassifizierungsmodells und Bewertung des Modells. Machine Learning-Pipelines optimieren Ihren Workflow mit Geschwindigkeit, Portabilität und Wiederverwendung, sodass Sie sich auf maschinelles Lernen statt auf Infrastruktur und Automatisierung konzentrieren können.

Die Beispielpipeline trainiert ein kleines keras konvolutionales neurales Netzwerk, um Bilder im Fashion MNIST-Dataset zu klassifizieren. Die Pipeline sieht wie folgt aus:

Screenshot eines Pipelinediagramms des Beispiels für die Bildklassifizierung.

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

  • Vorbereiten von Eingabedaten für den Pipelineauftrag.
  • Erstellen Sie drei Komponenten, um die Daten vorzubereiten, ein Bild zu trainieren und das Modell zu scoren.
  • Erstellen Sie eine Pipeline aus den Komponenten.
  • Erhalten Sie Zugriff auf einen Arbeitsbereich, der über Compute verfügt.
  • Übermitteln des Pipelineauftrags
  • Überprüfen der Ausgabe der Komponenten und des trainierten neuronalen Netzes.
  • (Optional) Registrieren Sie die Komponente für die weitere Wiederverwendung und 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

  • Ein Azure Machine Learning-Arbeitsbereich. Wenn Sie keins haben, schließen Sie bitte das Tutorial zum Erstellen von Ressourcen ab.

  • Eine Python-Umgebung, in der Sie Azure Machine Learning Python SDK v2 installiert haben. Installationsanweisungen finden Sie unter "Erste Schritte". Diese Umgebung dient zum Definieren und Steuern Ihrer Azure Machine Learning-Ressourcen und unterscheidet sich von der Umgebung, die zur Laufzeit für Schulungen verwendet wird.

  • Ein Klon des Beispiel-Repositorys.

    Um die Schulungsbeispiele auszuführen, klonen Sie zuerst das Beispielrepository, und wechseln Sie zum 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 Azure Machine Learning Python SDK zum Erstellen und Steuern einer Azure Machine Learning-Pipeline verwendet. Der Artikel wird basierend auf der Annahme geschrieben, dass Sie die Codeausschnitte interaktiv in einer Python REPL-Umgebung oder einem Jupyter-Notizbuch ausführen.

Dieser Artikel basiert auf dem image_classification_keras_minist_convnet.ipynb-Notizbuch , das Sie im sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet Verzeichnis des Azure Machine Learning-Beispielrepositorys finden können.

Importieren der erforderlichen Bibliotheken

Importieren Sie alle 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 die Bildklassifizierungspipeline vorbereiten.

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

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 zum Erstellen der Pipeline

Die Bildklassifizierungsaufgabe kann in drei Schritte unterteilt werden: Vorbereiten von Daten, Trainieren des Modells und Bewertung des Modells.

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

  • Bereiten Sie Daten für Schulungen vor, und testen Sie sie.
  • Trainieren eines neuralen Netzwerks für die Bildklassifizierung mithilfe von Schulungsdaten.
  • Bewertet das Modell mithilfe von Testdaten.

Für jede Komponente müssen Sie die folgenden Schritte ausführen:

  1. Vorbereiten des Python-Skripts, das die Ausführungslogik enthält.

  2. Definieren Sie die Schnittstelle der Komponente.

  3. Fügen Sie weitere Metadaten der Komponente hinzu, einschließlich der Laufzeitumgebung und des Befehls zum Ausführen der Komponente.

Im nächsten Abschnitt wird gezeigt, wie Sie die Komponenten auf zwei Arten erstellen. Für die ersten beiden Komponenten verwenden Sie eine Python-Funktion. Für die dritte Komponente verwenden Sie die YAML-Definition.

Erstellen der Datenvorbereitungskomponente

Die erste Komponente in dieser Pipeline konvertiert die komprimierten Datendateien von fashion_ds in zwei .csv-Dateien, eine für die Schulung und die andere für die Bewertung. Sie verwenden eine Python-Funktion, um diese Komponente zu definieren.

Wenn Sie dem Beispiel im Azure Machine Learning-Beispiel-Repository folgen, sind die Quelldateien bereits im prep Ordner verfügbar. Dieser Ordner enthält zwei Dateien zum Erstellen der Komponente: prep_component.py, die die Komponente definiert, und conda.yaml, die die Laufzeitumgebung der Komponente definiert.

Definieren der Komponente mithilfe einer Python-Funktion

Mithilfe der command_component() Funktion als Dekorateur können Sie die Schnittstelle der Komponente, deren Metadaten und den Code, der aus einer Python-Funktion ausgeführt werden soll, ganz einfach 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 vorangehende Code definiert eine Komponente mit Anzeigenamen Prep Data mithilfe des @command_component Dekorators:

  • name ist der eindeutige Bezeichner der Komponente.

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

  • display_name ist ein benutzerfreundlicher Anzeigename der Komponente für die Benutzeroberfläche. Es ist nicht einzigartig.

  • description in der Regel beschreibt die Aufgabe, die die Komponente abschließen kann.

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

    Die conda.yaml Datei 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.

  • Die Komponente konvertiert die Daten aus input_data in ein training_data .csv zur Datenverarbeitung für das Training und ein test_data .csv zur Datenverarbeitung für das Testen.

So sieht eine Komponente in der Studio-Benutzeroberfläche aus:

  • Eine Komponente ist ein Block in einem Pipelinegraphen.
  • input_data, training_dataund 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.

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

Erstellen der Modellschulungskomponente

In diesem Abschnitt erstellen Sie eine Komponente zum Trainieren des Bildklassifizierungsmodells in einer Python-Funktion, wie sie mit der Prep Data Komponente getan haben.

Da die Schulungslogik komplizierter ist, fügen Sie den Schulungscode in eine separate Python-Datei ein.

Die Quelldateien für diese Komponente befinden sich im train Ordner im Azure Machine Learning-Beispiel-Repository. Dieser Ordner enthält drei Dateien zum Erstellen der Komponente:

  • train.py enthält die Logik zum Trainieren des Modells.
  • train_component.py definiert die Schnittstelle der Komponente und importiert die Funktion, die sich in train.py befindet.
  • conda.yaml definiert die Laufzeitumgebung der Komponente.

Abrufen eines Skripts, das die Logik enthält

Die train.py Datei enthält eine normale Python-Funktion, die die Logik zum Trainieren eines neuralen Keras-Netzwerks für die Bildklassifizierung durchführt. Den Code finden Sie in der train.py-Datei auf GitHub.

Definieren der Komponente mithilfe einer Python-Funktion

Nachdem Sie die Schulungsfunktion definiert haben, können Sie im Azure Machine Learning SDK v2 ihre Funktion als Komponente umschließen, die in Azure Machine Learning-Pipelines verwendet werden kann @command_component :

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 vorangehende Code definiert eine Komponente, die den Anzeigenamen Train Image Classification Keras mit @command_component verwendet.

  • Die keras_train_component Funktion definiert eine Eingabe, input_datafür Quellschulungsdaten, eine Eingabe, epochsdie die Anzahl der epochen angibt, die während der Schulung verwendet werden sollen, und eine Ausgabe, output_modeldie den Ausgabepfad für die Modelldatei angibt. Der Standardwert von epochs ist 10. Die Logik dieser Komponente stammt aus der train() Funktion in train.py.

Die Trainingsmodell-Komponente verfügt über eine etwas komplexere Konfiguration als die Komponente zur Datenvorbereitung. conda.yaml sieht wie folgt aus:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.8
  - 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

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

Erstellen der Modellbewertungskomponente

In diesem Abschnitt erstellen Sie eine Komponente, um das trainierte Modell mithilfe der YAML-Spezifikation und des Skripts zu bewerten.

Wenn Sie dem Beispiel im Azure Machine Learning-Beispiel-Repository folgen, sind die Quelldateien bereits im score Ordner 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, das die Logik enthält

Die score.py Datei enthält eine normale Python-Funktion, die die Schulungsmodelllogik 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_modelund output_result. Das Programm bewertet das Eingabemodell mithilfe von Eingabedaten und gibt dann das Ergebnis aus.

Definieren der Komponente über YAML

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

  • Metadaten. Name, Anzeigename, Version, Typ usw.
  • Schnittstelle Eingaben und Ausgaben.
  • Befehl, Code und Umgebung. Der Befehl, code und die Umgebung, mit dem die Komponente ausgeführt wird.
$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 wird im code Abschnitt definiert. Wenn die Komponente in der Cloud ausgeführt wird, werden alle Dateien aus diesem Pfad als Momentaufnahme der Komponente hochgeladen.
  • Der command Abschnitt gibt den Befehl an, der ausgeführt werden soll, wenn die Komponente ausgeführt wird.
  • Der environment Abschnitt enthält ein Docker-Image und eine Conda-YAML-Datei. Die Quelldatei befindet sich im Beispielrepository.

Sie verfügen jetzt über alle Quelldateien für die Modellbewertungskomponente.

Laden der Komponenten zum Erstellen einer Pipeline

Sie können die Datenvorbereitungskomponente und die Modellschulungskomponente importieren, die von Python-Funktionen definiert werden, genau wie normale Python-Funktionen.

Der folgende Code importiert die prepare_data_component() Dateien und keras_train_component() Funktionen aus der prep_component.py Datei im prep Ordner bzw. die train_component Datei im train Ordner.

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

Sie können die load_component() Funktion verwenden, um die Scorekomponente zu laden, die von YAML definiert wird.

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

Erstellen Ihrer Pipeline

Sie haben alle Komponenten und Eingabedaten erstellt und geladen, um die Pipeline zu erstellen. Sie können sie jetzt zu einer Pipeline zusammenstellen.

Hinweis

Um serverlose Berechnung zu verwenden, fügen Sie from azure.ai.ml.entities import ResourceConfiguration am Anfang der Datei hinzu. Ersetzen Sie dann Folgendes:

  • default_compute=cpu_compute_target durch default_compute="serverless".
  • train_node.compute = gpu_compute_target durch 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 Standardcompute cpu_compute_target. Wenn Sie keine Berechnung für einen bestimmten Knoten angeben, wird dieser Knoten auf der Standardberechnung ausgeführt.

Die Pipeline verfügt über eine Eingabe auf Pipelineebene, pipeline_input_data. Sie können einer Pipelineneingabe einen Wert zuweisen, wenn Sie einen Pipelineauftrag einreichen.

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.

  • Das input_data von train_node ist die training_data Ausgabe von prepare_data_node.

  • Das input_data von score_node ist die test_data Ausgabe von prepare_data_node, und das input_model ist die output_model von train_node.

  • Da train_node ein CNN-Modell trainiert, können Sie angeben, dass die Berechnung als gpu_compute_target erfolgt. Dadurch kann die Trainingsleistung verbessert werden.

Senden Ihres Pipelineauftrags

Nachdem Sie die Pipeline erstellt haben, können Sie den Auftrag an Ihren Arbeitsbereich übermitteln. Um einen Auftrag einzureichen, müssen Sie zuerst eine Verbindung mit einem Arbeitsbereich herstellen.

Erteilen von Zugriff auf Ihren Arbeitsbereich

Konfigurieren von Anmeldeinformationen

Um Zugang zum Arbeitsbereich zu erhalten, verwenden Sie DefaultAzureCredential. DefaultAzureCredential sollte die meisten Azure SDK-Authentifizierungsszenarien abdecken können.

Wenn DefaultAzureCredential nicht für Sie funktioniert, sehen Sie sich dieses Beispiel zur Konfiguration von Anmeldeinformationen und das Identitätspaket an.

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

Zugriff auf ein Handles zu einem Arbeitsbereich, der über Compute verfügt

Erstellen Sie ein MLClient Objekt zum Verwalten von Azure Machine Learning-Diensten. Wenn Sie serverlose Berechnung verwenden, müssen Sie diese Berechnungen 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

Dieser Codeausschnitt erwartet, dass die JSON-Datei der Arbeitsbereichskonfiguration im aktuellen Verzeichnis oder im übergeordneten Verzeichnis gespeichert wird. Weitere Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen von Arbeitsbereichressourcen. Weitere Informationen zum Speichern der Konfiguration in einer Datei finden Sie unter Erstellen einer Arbeitsbereichskonfigurationsdatei.

Übermitteln des Pipelineauftrags an den Arbeitsbereich

Nachdem Sie nun über einen 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 vorangehende Code sendet diesen Pipelineauftrag für die Bildklassifizierung an ein Experiment mit dem Namen pipeline_samples. Es erstellt automatisch das Experiment, wenn es nicht vorhanden ist. pipeline_input_data verwendet fashion_ds.

Der Aufruf zur Einreichung des Experiments wird schnell abgeschlossen sein. Die Ausgabe wird ähnlich wie folgt erzeugt:

Experiment Name Typ Der Status Detailseite
pipeline_samples sharp_pipe_4gvqx6h1fb Rohrleitung Wird vorbereitet Link zu Azure Machine Learning Studio.

Sie können den Pipelinevorgang überwachen, indem Sie auf den Link klicken. Oder Sie können sie blockieren, bis sie abgeschlossen ist, indem Sie diesen Code ausführen:

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

Wichtig

Der erste Pipelinelauf dauert etwa 15 Minuten. Alle Abhängigkeiten werden heruntergeladen, 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 für die Pipeline hängt jedoch von der Arbeitsauslastung Ihrer Skripts und den Prozessen ab, die in den einzelnen Pipelineschritten ausgeführt werden.

Überprüfen von Ausgaben und Debuggen der Pipeline auf der Benutzeroberfläche

Sie können die Seite Link to Azure Machine Learning studio auswählen, die die Auftragsdetails Ihrer Pipeline enthält. Sie werden das Diagramm der Pipeline sehen:

Screenshot der Detailseite des Pipelineauftrags.

Sie können die Protokolle und Ausgaben jeder Komponente ü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 Der Pipeline auf der Benutzeroberfläche finden Sie unter Verwenden von Azure Machine Learning Studio zum Debuggen von Pipelinefehlern.

(Optional) Registrieren von Komponenten in den Arbeitsbereich

Im vorherigen Abschnitt haben Sie eine Pipeline mithilfe von drei Komponenten erstellt, um eine Imageklassifizierungsaufgabe abzuschließen. Sie können Komponenten auch für Ihren Arbeitsbereich registrieren, damit sie innerhalb des Arbeitsbereichs freigegeben und wiederverwendet werden können. Das folgende Beispiel zeigt, wie die Datenvorbereitungskomponente registriert wird:

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)

Sie können ml_client.components.get() verwenden, um eine registrierte Komponente nach Name und Version abzurufen. Sie können ml_client.components.create_or_update() verwenden, um eine Komponente zu registrieren, die zuvor aus einer Python-Funktion oder YAML geladen wurde.

Nächste Schritte