Tutorial: Erstellen einer Azure Machine Learning-Pipeline für die BatchbewertungTutorial: Build an Azure Machine Learning pipeline for batch scoring

In diesem Tutorial für Fortgeschrittene erfahren Sie, wie Sie eine Azure Machine Learning-Pipeline erstellen, um einen Batchbewertungsauftrag auszuführen.In this advanced tutorial, you learn how to build an Azure Machine Learning pipeline to run a batch scoring job. 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.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on machine learning instead of infrastructure and automation. Nach dem Erstellen und Veröffentlichen einer Pipeline konfigurieren Sie einen REST-Endpunkt, mit dem Sie die Pipeline von einer beliebigen HTTP-Bibliothek auf einer beliebigen Plattform aus auslösen.After you build and publish a pipeline, you configure a REST endpoint that you can use to trigger the pipeline from any HTTP library on any platform.

In diesem Beispiel wird ein vorab trainiertes Modell Inception-V3 eines künstlichen neuronalen Netzes (Convolutional Neural Network, CNN) verwendet, das in TensorFlow implementiert wird, um Bilder ohne Bezeichnung zu klassifizieren.The example uses a pretrained Inception-V3 convolutional neural network model implemented in Tensorflow to classify unlabeled images.

In diesem Tutorial führen Sie die folgenden Aufgaben durch:In this tutorial, you complete the following tasks:

  • Konfigurieren des ArbeitsbereichsConfigure workspace
  • Herunterladen und Speichern von BeispieldatenDownload and store sample data
  • Erstellen von Datasetobjekten zum Abrufen und Ausgeben von DatenCreate dataset objects to fetch and output data
  • Herunterladen, Vorbereiten und Registrieren des Modells in Ihrem ArbeitsbereichDownload, prepare, and register the model in your workspace
  • Bereitstellen von Computezielen und Erstellen eines BewertungsskriptsProvision compute targets and create a scoring script
  • Verwenden der ParallelRunStep-Klasse für die asynchrone BatchbewertungUse the ParallelRunStep class for async batch scoring
  • Erstellen, Ausführen und Veröffentlichen einer PipelineBuild, run, and publish a pipeline
  • Aktivieren eines REST-Endpunkts für die PipelineEnable a REST endpoint for the pipeline

Wenn Sie nicht über ein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.If you don't have an Azure subscription, create a free account before you begin. Probieren Sie die kostenlose oder kostenpflichtige Version von Azure Machine Learning noch heute aus.Try the free or paid version of Azure Machine Learning today.

VoraussetzungenPrerequisites

  • Absolvieren Sie Teil 1 des Einrichtungstutorials, falls Sie noch nicht über einen Azure Machine Learning-Arbeitsbereich oder einen virtuellen Notebook-Computer verfügen.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • Verwenden Sie nach Abschluss des Einrichtungstutorials den gleichen Notebook-Server, um das Notebook tutorials/machine-learning-pipelines-advanced/tutorial-pipeline-batch-scoring-classification.ipynb zu öffnen.When you finish the setup tutorial, use the same notebook server to open the tutorials/machine-learning-pipelines-advanced/tutorial-pipeline-batch-scoring-classification.ipynb notebook.

Falls Sie das Einrichtungstutorial in Ihrer eigenen lokalen Umgebung ausführen möchten, können Sie über GitHub auf das Tutorial zugreifen.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Führen Sie pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests aus, um die erforderlichen Pakete abzurufen.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests to get the required packages.

Konfigurieren eines Arbeitsbereichs und Erstellen eines DatenspeichersConfigure workspace and create a datastore

Erstellen Sie ein Arbeitsbereichsobjekt auf der Grundlage des vorhandenen Azure Machine Learning-Arbeitsbereichs.Create a workspace object from the existing Azure Machine Learning workspace.

from azureml.core import Workspace
ws = Workspace.from_config()

Wichtig

In diesem Codeausschnitt wird davon ausgegangen, dass die Arbeitsbereichskonfiguration im aktuellen Verzeichnis oder in dessen übergeordnetem Verzeichnis gespeichert wird.This code snippet expects the workspace configuration to be saved in the current directory or its parent. Weitere Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen und Verwalten von Azure Machine Learning-Arbeitsbereichen.For more information on creating a workspace, see Create and manage Azure Machine Learning workspaces. Weitere Informationen zum Speichern der Konfiguration in einer Datei finden Sie unter Konfigurieren einer Entwicklungsumgebung für Azure Machine Learning.For more information on saving the configuration to file, see Create a workspace configuration file.

Erstellen eines Datenspeichers für BeispielbilderCreate a datastore for sample images

Rufen Sie aus dem öffentlichen Blobcontainer sampledata für das Konto pipelinedata das öffentliche ImageNet-Bewertungsdatenbeispiel ab.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Rufen Sie register_azure_blob_container() auf, um die Daten im Arbeitsbereich unter dem Namen images_datastore verfügbar zu machen.Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. Legen Sie dann den Standarddatenspeicher des Arbeitsbereichs als Ausgabedatenspeicher fest.Then, set the workspace default datastore as the output datastore. Verwenden Sie den Ausgabedatenspeicher, um die Ausgabe in der Pipeline zu bewerten.Use the output datastore to score output in the pipeline.

Weitere Informationen zum Datenzugriff finden Sie unter Zugreifen auf Daten.For more information on accessing data, see How to access data.

from azureml.core.datastore import Datastore

batchscore_blob = Datastore.register_azure_blob_container(ws, 
                      datastore_name="images_datastore", 
                      container_name="sampledata", 
                      account_name="pipelinedata", 
                      overwrite=True)

def_data_store = ws.get_default_datastore()

Erstellen von DatasetobjektenCreate dataset objects

Bei der Pipelineerstellung werden Objekte vom Typ Dataset zum Lesen von Daten aus Arbeitsbereich-Datenspeichern und Objekte vom Typ OutputFileDatasetConfig zum Übertragen von Zwischendaten zwischen Pipelineschritten verwendet.When building pipelines, Dataset objects are used for reading data from workspace datastores, and OutputFileDatasetConfig objects are used for transferring intermediate data between pipeline steps.

Wichtig

Das Beispiel für die Batchbewertung in diesem Tutorial verwendet nur einen Pipelineschritt.The batch scoring example in this tutorial uses only one pipeline step. In Anwendungsfällen mit mehreren Schritten umfasst der typische Flow die folgenden Schritte:In use cases that have multiple steps, the typical flow will include these steps:

  1. Verwendung von Objekten vom Typ Dataset als Eingaben (zum Abrufen von Rohdaten), Ausführung von Transformationen sowie anschließende Ausgabe mit einem Objekt vom Typ OutputFileDatasetConfigUse Dataset objects as inputs to fetch raw data, perform some transformation, and then output with an OutputFileDatasetConfig object.

  2. Verwendung des Ausgabeobjekts OutputFileDatasetConfig aus dem vorherigen Schritt als Eingabeobjekt.Use the OutputFileDatasetConfig output object in the preceding step as an input object. Wiederholen Sie diesen Vorgang für nachfolgende Schritte.Repeat it for subsequent steps.

In diesem Szenario werden Objekte vom Typ Dataset erstellt, die den Datenspeicherverzeichnissen für Eingabebilder und Klassifizierungsbezeichnungen (y-Testwerte) entsprechen.In this scenario, you create Dataset objects that correspond to the datastore directories for both the input images and the classification labels (y-test values). Außerdem wird ein Objekt vom Typ OutputFileDatasetConfig für die Ausgabedaten der Batchbewertung erstellt.You also create an OutputFileDatasetConfig object for the batch scoring output data.

from azureml.core.dataset import Dataset
from azureml.data import OutputFileDatasetConfig

input_images = Dataset.File.from_files((batchscore_blob, "batchscoring/images/"))
label_ds = Dataset.File.from_files((batchscore_blob, "batchscoring/labels/"))
output_dir = OutputFileDatasetConfig(name="scores")

Registrieren Sie die Datasets im Arbeitsbereich, wenn Sie sie später wiederverwenden möchten.Register the datasets to the workspace if you want to reuse it later. Dieser Schritt ist optional.This step is optional.


input_images = input_images.register(workspace = ws, name = "input_images")
label_ds = label_ds.register(workspace = ws, name = "label_ds")

Herunterladen und Registrieren des ModellsDownload and register the model

Laden Sie das vortrainierte TensorFlow-Modell herunter, um es für die Batchbewertung in einer Pipeline zu verwenden.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. Erstellen Sie zunächst ein lokales Verzeichnis zum Speichern des Modells.First, create a local directory where you store the model. Laden Sie das Modell anschließend herunter, und extrahieren Sie es.Then, download and extract the model.

import os
import tarfile
import urllib.request

if not os.path.isdir("models"):
    os.mkdir("models")
    
response = urllib.request.urlretrieve("http://download.tensorflow.org/models/inception_v3_2016_08_28.tar.gz", "model.tar.gz")
tar = tarfile.open("model.tar.gz", "r:gz")
tar.extractall("models")

Registrieren Sie als Nächstes das Modell bei Ihrem Arbeitsbereich, um es im Pipelineprozess problemlos abrufen zu können.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. In der statischen Funktion register() ist der Parameter model_name der Schlüssel, den Sie innerhalb des SDK verwenden, um Ihr Modell zu finden.In the register() static function, the model_name parameter is the key you use to locate your model throughout the SDK.

from azureml.core.model import Model
 
model = Model.register(model_path="models/inception_v3.ckpt",
                       model_name="inception",
                       tags={"pretrained": "inception"},
                       description="Imagenet trained tensorflow inception",
                       workspace=ws)

Erstellen und Anfügen des RemotecomputezielsCreate and attach the remote compute target

Machine Learning-Pipelines können nicht lokal ausgeführt werden, daher führen Sie sie in Cloudressourcen oder auf Remotecomputezielen aus.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. Ein Remotecomputeziel ist eine wiederverwendbare virtuelle Compute-Umgebung, in der Sie Experimente und Machine Learning-Workflows ausführen.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

Führen Sie den folgenden Code aus, um ein GPU-fähiges Ziel vom Typ AmlCompute zu erstellen, und fügen Sie es an Ihren Arbeitsbereich an.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. Weitere Informationen zu Computezielen finden Sie in diesem Konzeptartikel.For more information about compute targets, see the conceptual article.

from azureml.core.compute import AmlCompute, ComputeTarget
from azureml.exceptions import ComputeTargetException
compute_name = "gpu-cluster"

# checks to see if compute target already exists in workspace, else create it
try:
    compute_target = ComputeTarget(workspace=ws, name=compute_name)
except ComputeTargetException:
    config = AmlCompute.provisioning_configuration(vm_size="STANDARD_NC6",
                                                   vm_priority="lowpriority", 
                                                   min_nodes=0, 
                                                   max_nodes=1)

    compute_target = ComputeTarget.create(workspace=ws, name=compute_name, provisioning_configuration=config)
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Schreiben eines BewertungsskriptsWrite a scoring script

Erstellen Sie für die Bewertung ein Batchbewertungsskript namens batch_scoring.py, und schreiben Sie es in das aktuelle Verzeichnis.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. Das Skript nimmt Eingabebilder entgegen, wendet das Klassifizierungsmodell an und gibt die Vorhersagen in eine Ergebnisdatei aus.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

Das Skript batch_scoring.py akzeptiert folgende Parameter. Sie werden vom später erstellten ParallelRunStep-Element übergeben:The batch_scoring.py script takes the following parameters, which get passed from the ParallelRunStep you create later:

  • --model_name: Der Name des verwendeten Modells--model_name: The name of the model being used.
  • --labels_dir: Der Speicherort der Datei labels.txt.--labels_dir: The location of the labels.txt file.

Die Pipelineinfrastruktur verwendet die Klasse ArgumentParser, um Parameter an Pipelineschritte zu übergeben.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. Im folgenden Code erhält beispielsweise das erste Argument (--model_name) den Eigenschaftsbezeichner model_name.For example, in the following code, the first argument --model_name is given the property identifier model_name. In der Funktion init() wird Model.get_model_path(args.model_name) für den Zugriff auf diese Eigenschaft verwendet.In the init() function, Model.get_model_path(args.model_name) is used to access this property.

%%writefile batch_scoring.py

import os
import argparse
import datetime
import time
import tensorflow as tf
from math import ceil
import numpy as np
import shutil
from tensorflow.contrib.slim.python.slim.nets import inception_v3

from azureml.core import Run
from azureml.core.model import Model
from azureml.core.dataset import Dataset

slim = tf.contrib.slim

image_size = 299
num_channel = 3


def get_class_label_dict(labels_dir):
    label = []
    labels_path = os.path.join(labels_dir, 'labels.txt')
    proto_as_ascii_lines = tf.gfile.GFile(labels_path).readlines()
    for l in proto_as_ascii_lines:
        label.append(l.rstrip())
    return label


def init():
    global g_tf_sess, probabilities, label_dict, input_images

    parser = argparse.ArgumentParser(description="Start a tensorflow model serving")
    parser.add_argument('--model_name', dest="model_name", required=True)
    parser.add_argument('--labels_dir', dest="labels_dir", required=True)
    args, _ = parser.parse_known_args()

    label_dict = get_class_label_dict(args.labels_dir)
    classes_num = len(label_dict)

    with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
        input_images = tf.placeholder(tf.float32, [1, image_size, image_size, num_channel])
        logits, _ = inception_v3.inception_v3(input_images,
                                              num_classes=classes_num,
                                              is_training=False)
        probabilities = tf.argmax(logits, 1)

    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    g_tf_sess = tf.Session(config=config)
    g_tf_sess.run(tf.global_variables_initializer())
    g_tf_sess.run(tf.local_variables_initializer())

    model_path = Model.get_model_path(args.model_name)
    saver = tf.train.Saver()
    saver.restore(g_tf_sess, model_path)


def file_to_tensor(file_path):
    image_string = tf.read_file(file_path)
    image = tf.image.decode_image(image_string, channels=3)

    image.set_shape([None, None, None])
    image = tf.image.resize_images(image, [image_size, image_size])
    image = tf.divide(tf.subtract(image, [0]), [255])
    image.set_shape([image_size, image_size, num_channel])
    return image


def run(mini_batch):
    result_list = []
    for file_path in mini_batch:
        test_image = file_to_tensor(file_path)
        out = g_tf_sess.run(test_image)
        result = g_tf_sess.run(probabilities, feed_dict={input_images: [out]})
        result_list.append(os.path.basename(file_path) + ": " + label_dict[result[0]])
    return result_list

Tipp

Die Pipeline in diesem Tutorial enthält nur einen Schritt, und die Ausgabe wird in eine Datei geschrieben.The pipeline in this tutorial has only one step, and it writes the output to a file. Für Pipelines mit mehreren Schritten verwenden Sie zudem ArgumentParser zum Definieren eines Verzeichnisses, um Ausgabedaten für die Eingabe in nachfolgende Schritte zu schreiben.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. Im ArgumentParserNotebook finden Sie ein Beispiel für die Übergabe von Daten zwischen mehreren Pipelineschritten unter Verwendung des Entwurfsmusters .For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

Erstellen der PipelineBuild the pipeline

Bevor Sie die Pipeline ausführen können, müssen Sie ein Objekt erstellen, das die Python-Umgebung definiert und die erforderlichen Abhängigkeiten für Ihr Skript (batch_scoring.py) erstellt.Before you run the pipeline, create an object that defines the Python environment and creates the dependencies that your batch_scoring.py script requires. Die wichtigste erforderliche Abhängigkeit ist TensorFlow, aber Sie installieren auch azureml-core und azureml-dataprep[fuse], die für ParallelRunStep erforderlich sind.The main dependency required is Tensorflow, but you also install azureml-core and azureml-dataprep[fuse] which are required by ParallelRunStep. Geben Sie auch Docker- und Docker-GPU-Unterstützung an.Also, specify Docker and Docker-GPU support.

from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_GPU_IMAGE

cd = CondaDependencies.create(pip_packages=["tensorflow-gpu==1.15.2",
                                            "azureml-core", "azureml-dataprep[fuse]"])
env = Environment(name="parallelenv")
env.python.conda_dependencies = cd
env.docker.base_image = DEFAULT_GPU_IMAGE

Erstellen der Konfiguration zum Umschließen des SkriptsCreate the configuration to wrap the script

Erstellen Sie den Pipelineschritt mithilfe des Skripts, der Umgebungskonfiguration und der Parameter.Create the pipeline step using the script, environment configuration, and parameters. Geben Sie das Computeziel an, das Sie bereits an Ihren Arbeitsbereich angefügt haben.Specify the compute target you already attached to your workspace.

from azureml.pipeline.steps import ParallelRunConfig

parallel_run_config = ParallelRunConfig(
    environment=env,
    entry_script="batch_scoring.py",
    source_directory=".",
    output_action="append_row",
    mini_batch_size="20",
    error_threshold=1,
    compute_target=compute_target,
    process_count_per_node=2,
    node_count=1
)

Erstellen des PipelineschrittsCreate the pipeline step

Ein Pipelineschritt ist ein Objekt, das alles kapselt, was Sie zum Ausführen einer Pipeline benötigen:A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Umgebungs- und AbhängigkeitseinstellungenEnvironment and dependency settings
  • Die Computeressource für die PipelineausführungThe compute resource to run the pipeline on
  • Eingabe- und Ausgabedaten sowie ggf. benutzerdefinierte ParameterInput and output data, and any custom parameters
  • Verweis auf ein Skript oder eine SDK-Logik, die während des Schritts ausgeführt werden sollReference to a script or SDK logic to run during the step

Mehrere Klassen erben von der übergeordneten Klasse PipelineStep.Multiple classes inherit from the parent class PipelineStep. Sie können Klassen auswählen, um bestimmte Frameworks oder Stapel zum Erstellen eines Schritts zu verwenden.You can choose classes to use specific frameworks or stacks to build a step. In diesem Beispiel wird die Klasse ParallelRunStep verwendet, um Ihre Schrittlogik mithilfe eines benutzerdefinierten Python-Skripts zu definieren.In this example, you use the ParallelRunStep class to define your step logic by using a custom Python script. Wenn es sich bei einem Argument für Ihr Skript um eine Eingabe für den Schritt oder um eine Ausgabe des Schritts handelt, muss es sowohl im Array argumentsals auch im Parameter input bzw. output definiert werden.If an argument to your script is either an input to the step or an output of the step, the argument must be defined both in the arguments array and in either the input or the output parameter, respectively.

In Szenarien mit mehreren Schritten wird ein Objektverweis im Array outputs als Eingabe für einen nachfolgenden Pipelineschritt verfügbar.In scenarios where there is more than one step, an object reference in the outputs array becomes available as an input for a subsequent pipeline step.

from azureml.pipeline.steps import ParallelRunStep
from datetime import datetime

parallel_step_name = "batchscoring-" + datetime.now().strftime("%Y%m%d%H%M")

label_config = label_ds.as_named_input("labels_input")

batch_score_step = ParallelRunStep(
    name=parallel_step_name,
    inputs=[input_images.as_named_input("input_images")],
    output=output_dir,
    arguments=["--model_name", "inception",
               "--labels_dir", label_config],
    side_inputs=[label_config],
    parallel_run_config=parallel_run_config,
    allow_reuse=False
)

Eine Liste mit allen Klassen für verschiedene Schritttypen finden Sie im Schrittpaket.For a list of all the classes you can use for different step types, see the steps package.

Übermitteln der PipelineSubmit the pipeline

Führen Sie die Pipeline nun aus.Now, run the pipeline. Erstellen Sie zunächst ein Objekt vom Typ Pipeline mit einem Verweis auf Ihren Arbeitsbereich sowie mit dem erstellten Pipelineschritt.First, create a Pipeline object by using your workspace reference and the pipeline step you created. Der Parameter steps ist ein Array mit Schritten.The steps parameter is an array of steps. In diesem Fall ist allerdings nur ein Schritt für die Batchbewertung vorhanden.In this case, there's only one step for batch scoring. Wenn Sie Pipelines mit mehreren Schritten erstellen möchten, müssen Sie die Schritte in der gewünschten Reihenfolge in diesem Array platzieren.To build pipelines that have multiple steps, place the steps in order in this array.

Verwenden Sie als Nächstes die Funktion Experiment.submit(), um die Pipeline für die Ausführung zu übermitteln.Next, use the Experiment.submit() function to submit the pipeline for execution. Die Funktion wait_for_completion gibt während der Pipelineerstellung Protokolle aus.The wait_for_completion function outputs logs during the pipeline build process. Anhand der Protokolle können Sie den aktuellen Status anzeigen.You can use the logs to see current progress.

Wichtig

Die erste Pipelineausführung dauert ungefähr 15 Minuten.The first pipeline run takes roughly 15 minutes. Alle Abhängigkeiten müssen heruntergeladen werden, ein Docker-Image wird erstellt, und die Python-Umgebung wird bereitgestellt und erstellt.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. Die erneute Ausführung der Pipeline ist dagegen deutlich schneller, da diese Ressourcen wiederverwendet und nicht neu erstellt werden.Running the pipeline again takes significantly less time because those resources are reused instead of created. 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.However, total run time for the pipeline depends on the workload of your scripts and the processes that are running in each pipeline step.

from azureml.core import Experiment
from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[batch_score_step])
pipeline_run = Experiment(ws, 'Tutorial-Batch-Scoring').submit(pipeline)
pipeline_run.wait_for_completion(show_output=True)

Herunterladen und Überprüfen der AusgabeDownload and review output

Führen Sie den folgenden Code aus, um die durch das Skript batch_scoring.py erstellte Ausgabedatei herunterzuladen.Run the following code to download the output file that's created from the batch_scoring.py script. Sehen Sie sich anschließend die Bewertungsergebnisse an.Then, explore the scoring results.

import pandas as pd

batch_run = next(pipeline_run.get_children())
batch_output = batch_run.get_output_data("scores")
batch_output.download(local_path="inception_results")

for root, dirs, files in os.walk("inception_results"):
    for file in files:
        if file.endswith("parallel_run_step.txt"):
            result_file = os.path.join(root, file)

df = pd.read_csv(result_file, delimiter=":", header=None)
df.columns = ["Filename", "Prediction"]
print("Prediction has ", df.shape[0], " rows")
df.head(10)

Veröffentlichen und Ausführen über einen REST-EndpunktPublish and run from a REST endpoint

Führen Sie den folgenden Code aus, um die Pipeline in Ihrem Arbeitsbereich zu veröffentlichen.Run the following code to publish the pipeline to your workspace. In Ihrem Arbeitsbereich in Azure Machine Learning werden Metadaten für die Pipeline angezeigt. Hierzu zählen unter anderem Ausführungsverlauf und -dauer.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. Über Studio kann die Pipeline auch manuell ausgeführt werden.You can also run the pipeline manually from the studio.

Durch die Veröffentlichung der Pipeline wird ein REST-Endpunkt aktiviert, über den Sie die Pipeline von einer beliebigen HTTP-Bibliothek auf einer beliebigen Plattform aus ausführen können.Publishing the pipeline enables a REST endpoint that you can use to run the pipeline from any HTTP library on any platform.

published_pipeline = pipeline_run.publish_pipeline(
    name="Inception_v3_scoring", description="Batch scoring using Inception v3 model", version="1.0")

published_pipeline

Um die Pipeline über den REST-Endpunkt ausführen zu können, benötigen Sie einen OAuth2-Bearer-Authentifizierungsheader.To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. Im folgenden Beispiel wird zur Veranschaulichung eine interaktive Authentifizierung verwendet. In den meisten Produktionsszenarios, die eine automatisierte oder monitorlose Authentifizierung erfordern, wird dagegen eine Dienstprinzipalauthentifizierung verwendet, wie in diesem Artikel beschrieben.The following example uses interactive authentication (for illustration purposes), but for most production scenarios that require automated or headless authentication, use service principal authentication as described in this article.

Für die Dienstprinzipalauthentifizierung muss eine App-Registrierung in Azure Active Directory erstellt werden.Service principal authentication involves creating an App Registration in Azure Active Directory. Sie generieren zunächst einen geheimen Clientschlüssel und gewähren dem Dienstprinzipal anschließend Rollenzugriff auf Ihren Machine Learning-Arbeitsbereich.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Verwenden Sie zur Verwaltung des Authentifizierungsflusses die Klasse ServicePrincipalAuthentication.Use the ServicePrincipalAuthentication class to manage your authentication flow.

InteractiveLoginAuthentication und ServicePrincipalAuthentication erben jeweils von AbstractAuthentication.Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. In beiden Fällen wird die Funktion get_authentication_header() auf die gleiche Weise verwendet, um den Header abzurufen:In both cases, use the get_authentication_header() function in the same way to fetch the header:

from azureml.core.authentication import InteractiveLoginAuthentication

interactive_auth = InteractiveLoginAuthentication()
auth_header = interactive_auth.get_authentication_header()

Rufen Sie die REST-URL aus der Eigenschaft endpoint des veröffentlichten Pipelineobjekts ab.Get the REST URL from the endpoint property of the published pipeline object. Sie finden die REST-URL auch in Ihrem Arbeitsbereich in Azure Machine Learning Studio.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Erstellen Sie eine HTTP POST-Anforderung für den Endpunkt.Build an HTTP POST request to the endpoint. Geben Sie Ihren Authentifizierungsheader in der Anforderung an.Specify your authentication header in the request. Fügen Sie ein JSON-Nutzlastobjekt mit dem Namen des Experiments hinzu.Add a JSON payload object that has the experiment name.

Übermitteln Sie die Anforderung, um die Ausführung auszulösen.Make the request to trigger the run. Fügen Sie Code ein, um zum Abrufen des Werts der Ausführungs-ID auf den Schlüssel Id aus dem Antwortwörterbuch zuzugreifen.Include code to access the Id key from the response dictionary to get the value of the run ID.

import requests

rest_endpoint = published_pipeline.endpoint
response = requests.post(rest_endpoint, 
                         headers=auth_header, 
                         json={"ExperimentName": "Tutorial-Batch-Scoring",
                               "ParameterAssignments": {"process_count_per_node": 6}})
run_id = response.json()["Id"]

Verwenden Sie die Ausführungs-ID, um den Status der neuen Ausführung zu überwachen.Use the run ID to monitor the status of the new run. Die neue Ausführung dauert ungefähr weitere zehn bis 15 Minuten.The new run takes another 10-15 min to finish.

Sie gleicht der weiter oben in diesem Tutorial ausgeführten Pipeline.The new run will look similar to the pipeline you ran earlier in the tutorial. Sie können festlegen, dass nicht die vollständige Ausgabe angezeigt wird.You can choose not to view the full output.

from azureml.pipeline.core.run import PipelineRun
from azureml.widgets import RunDetails

published_pipeline_run = PipelineRun(ws.experiments["Tutorial-Batch-Scoring"], run_id)
RunDetails(published_pipeline_run).show()

Bereinigen von RessourcenClean up resources

Überspringen Sie diesen Abschnitt, wenn Sie weitere Azure Machine Learning-Tutorials absolvieren möchten.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Beenden der Compute-InstanzStop the compute instance

Sollten Sie eine Compute-Instanz oder eine Notebook-VM verwendet haben, beenden Sie die VM, wenn Sie sie nicht verwenden, um Kosten zu sparen.If you used a compute instance or Notebook VM, stop the VM when you aren't using it to reduce cost.

  1. Wählen Sie in Ihrem Arbeitsbereich die Option Compute aus.In your workspace, select Compute.

  2. Wählen Sie die VM in der Liste aus.From the list, select the VM.

  3. Wählen Sie Stop (Beenden) aus.Select Stop.

  4. Wenn Sie bereit sind, den Server erneut zu verwenden, wählen Sie Starten aus.When you're ready to use the server again, select Start.

Alles löschenDelete everything

Wenn Sie die erstellten Ressourcen nicht mehr benötigen, löschen Sie sie, damit Ihnen keine Kosten entstehen:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Wählen Sie im Azure-Portal im linken Menü die Option Ressourcengruppen aus.In the Azure portal, in the left menu, select Resource groups.
  2. Wählen Sie in der Liste der Ressourcengruppen die von Ihnen erstellte Ressourcengruppe aus.In the list of resource groups, select the resource group you created.
  3. Wählen Sie die Option Ressourcengruppe löschen.Select Delete resource group.
  4. Geben Sie den Ressourcengruppennamen ein.Enter the resource group name. Wählen Sie dann Löschen aus.Then, select Delete.

Sie können die Ressourcengruppe auch behalten und einen einzelnen Arbeitsbereich löschen.You can also keep the resource group but delete a single workspace. Zeigen Sie die Eigenschaften des Arbeitsbereichs an, und wählen Sie Löschen aus.Display the workspace properties, and then select Delete.

Nächste SchritteNext steps

In diesem Tutorial zu Machine Learning-Pipelines haben Sie folgende Aufgaben ausgeführt:In this machine learning pipelines tutorial, you did the following tasks:

  • Erstellen einer Pipeline mit Umgebungsabhängigkeiten, die auf einer Remote-GPU-Computeressource ausgeführt werden kannBuilt a pipeline with environment dependencies to run on a remote GPU compute resource.
  • Erstellen eines Bewertungsskripts zum Ausführen von Batchvorhersagen mit einem vortrainierten TensorFlow-ModellCreated a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • Veröffentlichen einer Pipeline und Ermöglichen der Ausführung über einen REST-EndpunktPublished a pipeline and enabled it to be run from a REST endpoint.

Weitere Beispiele zum Erstellen von Pipelines mithilfe des Machine Learning SDK finden Sie im Notebook-Repository.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.