Freigeben über

Erstellen und Ausführen von Machine Learning-Pipelines mithilfe von Komponenten mit dem Azure 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 mit dem Azure Machine Learning Python SDK v2 erstellen, um eine Imageklassifizierungsaufgabe abzuschließen. Diese Pipeline enthält drei Schritte: Vorbereiten von Daten, Trainieren eines Bildklassifizierungsmodells 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 von drei Komponenten zum Vorbereiten von Daten, Trainieren eines Modells und Bewertung des Modells
  • Erstellen einer Pipeline aus den Komponenten
  • Zugriff auf einen Arbeitsbereich, der über Compute verfügt
  • Reichen Sie den Pipelineauftrag ein
  • Überprüfen der Ausgabe der Komponenten und des trainierten neuronalen Netzes
  • (Optional) Registrieren der Komponente für 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 mit installiertem Azure Machine Learning Python SDK v2. Installationsanweisungen finden Sie unter "Erste Schritte". 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.
  • Ein Klon des Beispiel-Repositorys.

Um die Schulungsbeispiele auszuführen, klonen Sie zuerst das Beispielrepository, und navigieren 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. In diesem Artikel wird davon ausgegangen, dass Sie die Codeausschnitte interaktiv in einer Python REPL-Umgebung oder in einem Jupyter-Notizbuch ausführen.

Dieser Artikel basiert auf dem image_classification_keras_minist_convnet.ipynb-Notizbuch im sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet Verzeichnis des Azure Machine Learning-Beispielrepositorys .

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.

import urllib3
import shutil
import gzip
import os
from pathlib import Path
from azure.ai.ml import Input

base_url = "https://azureopendatastorage.blob.core.windows.net/mnist/"
base_dir = Path("mnist")
if not base_dir.exists():
    base_dir.mkdir(parents=True)

c = urllib3.PoolManager()
for target_file in [
    "train-images-idx3-ubyte.gz",
    "train-labels-idx1-ubyte.gz",
    "t10k-images-idx3-ubyte.gz",
    "t10k-labels-idx1-ubyte.gz",
]:
    if (base_dir / target_file[:-3]).exists():
        continue
    with c.request("GET", base_url + target_file, preload_content=False) as resp, open(
        base_dir / target_file, "wb"
    ) as out_file:
        shutil.copyfileobj(resp, out_file)
        resp.release_conn()
    with gzip.open(base_dir / target_file, "rb") as f_in, open(
        base_dir / target_file[:-3], "wb"
    ) as f_out:
        shutil.copyfileobj(f_in, f_out)
    os.unlink(base_dir / target_file)

mnist_ds = Input(path=base_dir.as_posix())

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:

  • Vorbereiten von Daten für Schulungen und Tests
  • Trainieren eines neuralen Netzwerks zur Bildklassifizierung mithilfe von Schulungsdaten
  • Bewertung des Modells mithilfe von Testdaten

Für jede Komponente führen Sie die folgenden Schritte aus:

  1. Vorbereiten des Python-Skripts, das die Ausführungslogik enthält
  2. Definieren der Schnittstelle der Komponente
  3. Fügen Sie weitere Metadaten der Komponente hinzu, einschließlich der Laufzeitumgebung und des Befehls zum Ausführen der Komponente.

In den nächsten Abschnitten 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 einer Komponente mithilfe einer Python-Funktion

Mithilfe der command_component() Funktion als Dekorateur können Sie ganz einfach die Schnittstelle der Komponente, deren Metadaten und den Code definieren, der von einer Python-Funktion ausgeführt werden soll. Jede dekorierte Python-Funktion wird in eine einzelne statische Spezifikation (YAML) transformiert, die der Pipelinedienst verarbeiten 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 über mehrere Versionen verfügen

  • display_name ist ein freundlicher Anzeigename der Komponente für die Benutzeroberfläche.

  • description beschreibt die Aufgabe, die die Komponente abschließen kann

  • environment Gibt die Laufzeitumgebung für die Komponente mithilfe einer Conda.yaml-Datei an.

    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 prepare_data_component Funktion 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 Schulungsdaten und Testdaten

  • Die Komponente konvertiert die Daten aus input_data in eine training_data .csv-Datei für Schulungsdaten und in eine test_data .csv-Datei für Testdaten.

In der Studio-Benutzeroberfläche wird eine Komponente angezeigt als:

  • Ein Block in einem Pipelinediagramm
  • 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 mithilfe einer Python-Funktion, wie sie mit der Prep Data Komponente getan haben.

Da die Schulungslogik komplexer 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 aus train.py
  • 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 @command_component Funktion als Komponente für die Verwendung in Azure Machine Learning-Pipelines umhüllen.

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 mit dem Anzeigenamen Train Image Classification Keras mithilfe von @command_component.

Die keras_train_component Funktion definiert Folgendes:

  • Eine Eingabe, input_data für Quellschulungsdaten
  • Eine Eingabe, die die Anzahl der Epochen angibt, epochsdie während des Trainings verwendet werden sollen
  • 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 Trainingsmodellkomponente verfügt über eine 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 von YAML-Spezifikation und Skript 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 Modellbewertungslogik 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 mithilfe von 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 ist 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 Beispiel-Repository.

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

Laden registrierter Komponenten aus dem Arbeitsbereich

Hinweis

Um registrierte Komponenten aus Ihrem Arbeitsbereich zu laden, müssen Sie zuerst Ihre Arbeitsbereichsverbindung konfigurieren, wie im Abschnitt "Zugriff auf Ihren Arbeitsbereich abrufen" beschrieben. Das ml_client Objekt ist für die folgenden Vorgänge erforderlich.

Wenn Sie Komponenten haben, die bereits in Ihrem Arbeitsbereich registriert sind, können Sie sie direkt mit der ml_client.components.get() Methode laden. Dieser Ansatz ist nützlich, wenn Sie Komponenten wiederverwenden möchten, die zuvor von Ihnen registriert oder von anderen Teammitgliedern freigegeben wurden.

# Load a registered component by name and version
registered_component = ml_client.components.get(
    name="my_registered_component", 
    version="1.0.0"
)

# Load the latest version of a registered component
latest_component = ml_client.components.get(
    name="my_registered_component"
)

Sie können alle verfügbaren Komponenten in Ihrem Arbeitsbereich auflisten, um die benötigten Komponenten zu finden:

# List all components in the workspace
components = ml_client.components.list()
for component in components:
    print(f"Name: {component.name}, Version: {component.version}")

Nach dem Laden können Sie registrierte Komponenten in Ihrer Pipeline genau wie Komponenten verwenden, die aus lokalen Dateien oder Python-Funktionen geladen wurden.

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

  • Der input_data des prepare_data_node verwendet den Wert von pipeline_input_data
  • Die 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 gpu_compute_target als Compute festlegen, um die Trainingsleistung zu verbessern.

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

Sie verwenden DefaultAzureCredential, um Zugriff auf den Arbeitsbereich zu erhalten. 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 zum Übermitteln des Experiments wird schnell abgeschlossen und erzeugt eine ähnliche Ausgabe wie die folgende:

Experiment Name type 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 warten, 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. Das erneute Ausführen der Pipeline nimmt weniger Zeit in Anspruch, da diese Ressourcen wiederverwendet werden, statt neu erstellt zu 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. Du siehst das Pipelinediagramm.

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

In den vorherigen Abschnitten haben Sie eine Pipeline mit 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

  • Last updated on