Zelfstudie: Een Azure Machine Learning-pijplijn bouwen voor batchgewijs scorenTutorial: Build an Azure Machine Learning pipeline for batch scoring

In deze geavanceerde zelfstudie leert u hoe u een Azure Machine Learning-pijplijn kunt bouwen om een taak voor batchgewijs scoren uit te voeren.In this advanced tutorial, you learn how to build an Azure Machine Learning pipeline to run a batch scoring job. Machine Learning-pijplijnen optimaliseren uw werkstroom met snelheid, draagbaarheid en hergebruik, zodat u zich kunt concentreren op machine learning in plaats van op infrastructuur en automatisering.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on machine learning instead of infrastructure and automation. Nadat u een pijplijn hebt gemaakt en gepubliceerd, configureert u een REST-eindpunt dat u kunt gebruiken om de pijplijn te activeren vanuit elke HTTP-bibliotheek en op elk platform.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 het voorbeeld wordt gebruikgemaakt van een vooraf getraind convolutioneel neuraal netwerkmodel Inception-V3 dat is geïmplementeerd in Tensorflow om ongelabelde afbeeldingen te classificeren.The example uses a pretrained Inception-V3 convolutional neural network model implemented in Tensorflow to classify unlabeled images.

In deze zelfstudie voert u de volgende taken uit:In this tutorial, you complete the following tasks:

  • Werkruimte configurerenConfigure workspace
  • Voorbeeldgegevens downloaden en opslaanDownload and store sample data
  • Gegevensobjecten maken om gegevens op te halen en uit te voerenCreate dataset objects to fetch and output data
  • Het model downloaden, voorbereiden en registreren in uw werkruimteDownload, prepare, and register the model in your workspace
  • Rekendoelen inrichten en een scoringscript makenProvision compute targets and create a scoring script
  • De klasse ParallelRunStep voor asynchroon batchgewijs scoren gebruikenUse the ParallelRunStep class for async batch scoring
  • Een pijplijn bouwen, uitvoeren en publicerenBuild, run, and publish a pipeline
  • Een REST-eindpunt inschakelen voor de pijplijnEnable a REST endpoint for the pipeline

Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.If you don't have an Azure subscription, create a free account before you begin. Probeer vandaag nog de gratis of betaalde versie van Azure Machine Learning.Try the free or paid version of Azure Machine Learning today.

VereistenPrerequisites

  • Doorloop deel 1 van de installatiezelfstudie als u nog geen Azure Machine Learning-werkruimte of virtuele notebook-machine hebt.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • Wanneer u de installatiezelfstudie hebt voltooid, gebruikt u dezelfde notebook-server om de notebook tutorials/machine-learning-pipelines-advanced/tutorial-pipeline-batch-scoring-classification.ipynb te openen.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.

Als u de installatiehandleiding wilt uitvoeren in uw eigen lokale omgeving, kunt u de zelfstudie op GitHub openen.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Voer pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests uit om de vereiste pakketten te downloaden.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests to get the required packages.

Een werkruimte configureren en een gegevensopslag makenConfigure workspace and create a datastore

Maak een werkruimteobject op basis van de bestaande Azure Machine Learning-werkruimte.Create a workspace object from the existing Azure Machine Learning workspace.

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

Belangrijk

Dit codefragment verwacht dat de werkruimteconfiguratie wordt opgeslagen in de huidige of de bovenliggende map.This code snippet expects the workspace configuration to be saved in the current directory or its parent. Zie Azure Machine Learning-werkruimten maken en beheren voor meer informatie over het maken van een werkruimte.For more information on creating a workspace, see Create and manage Azure Machine Learning workspaces. Zie Een configuratiebestand voor een werkruimte maken voor meer informatie over de configuratie als bestand opslaan.For more information on saving the configuration to file, see Create a workspace configuration file.

Een gegevensarchief maken voor voorbeeldafbeeldingenCreate a datastore for sample images

Haal op het pipelinedata-account het voorbeeld van de openbare gegevens van de ImageNet-evaluatie op uit de openbare blob-container van sampledata.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Roep register_azure_blob_container() aan om de gegevens beschikbaar te maken voor de werkruimte onder de naam images_datastore.Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. Stel vervolgens het standaard gegevensarchief voor de werkruimte in als het gegevensarchief voor uitvoer.Then, set the workspace default datastore as the output datastore. Gebruik het gegevensarchief voor uitvoer om uitvoer in de pijplijn te scoren.Use the output datastore to score output in the pipeline.

Zie Toegang krijgen tot gegevens voor meer informatie over toegang tot gegevens.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()

Gegevenssetobjecten makenCreate dataset objects

Wanneer u pijplijnen bouwt, worden Dataset-objecten gebruikt voor het lezen van gegevens uit gegevensarchieven van werkruimtes en worden PipelineData-objecten gebruikt voor het overzetten van tussenliggende gegevens tussen pijplijnstappen.When building pipelines, Dataset objects are used for reading data from workspace datastores, and PipelineData objects are used for transferring intermediate data between pipeline steps.

Belangrijk

In het voorbeeld voor batchgewijs scoren in deze zelfstudie wordt slechts één pijplijnstap gebruikt.The batch scoring example in this tutorial uses only one pipeline step. In gebruiksvoorbeelden met meerdere stappen bevat de typische stroom de volgende stappen:In use cases that have multiple steps, the typical flow will include these steps:

  1. Gebruik Dataset-objecten als invoer om onbewerkte gegevens op te halen, een transformatie uit te voeren en een PipelineData-object uit te voeren.Use Dataset objects as inputs to fetch raw data, perform some transformation, and then output a PipelineData object.

  2. Gebruik het uitvoerobject PipelineData in de vorige stap als een invoerobject.Use the PipelineData output object in the preceding step as an input object. Herhaal dit voor de volgende stappen.Repeat it for subsequent steps.

In dit scenario maakt u Dataset-objecten die overeenkomen met de gegevensopslagmappen voor zowel de invoerafbeeldingen als de classificatielabels (y-test waarden).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). U maakt ook een PipelineData-object voor de uitvoergegevens voor batchgewijs scoren.You also create a PipelineData object for the batch scoring output data.

from azureml.core.dataset import Dataset
from azureml.pipeline.core import PipelineData

input_images = Dataset.File.from_files((batchscore_blob, "batchscoring/images/"))
label_ds = Dataset.File.from_files((batchscore_blob, "batchscoring/labels/"))
output_dir = PipelineData(name="scores", 
                          datastore=def_data_store, 
                          output_path_on_compute="batchscoring/results")

Registreer vervolgens de gegevenssets in de werkruimte.Next, register the datasets to the workspace.


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

Het model downloaden en registrerenDownload and register the model

Download het vooraf getrainde Tensorflow-model om het te gebruiken voor batchgewijs scoren in een pijplijn.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. Maak eerst een lokale map waarin u het model opslaat.First, create a local directory where you store the model. Vervolgens downloadt en extraheert u het model.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")

Registreer vervolgens het model in uw werkruimte, zodat u het model eenvoudig kunt ophalen in het pijplijnproces.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. In de statische functie register() is de parameter model_name de sleutel die u gebruikt om uw model in de SDK te vinden.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)

Het externe rekendoel maken en koppelenCreate and attach the remote compute target

Machine learning-pijplijnen kunnen niet lokaal worden uitgevoerd, dus u kunt ze uitvoeren op cloudresources of externe rekendoelen.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. Een extern rekendoel is een herbruikbare virtuele rekenomgeving waarin u experimenten en machine learning-werkstromen kunt uitvoeren.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

Voer de volgende code uit om een AmlCompute-doel met GPU te maken en deze vervolgens aan uw werkruimte te koppelen.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. Zie het conceptuele artikel voor meer informatie over rekendoelen.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)

Een scorescript schrijvenWrite a scoring script

Als u wilt scoren, maakt u een script voor batchgewijs scoren met de naam batch_scoring.py en schrijft u het naar de huidige map.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. Het script gebruikt invoerafbeeldingen, past het classificatiemodel toe en voert vervolgens de voorspellingen uit naar een bestand met resultaten.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

Het script batch_scoring.py gebruikt de volgende parameters, die worden doorgegeven aan de ParallelRunStep die u later maakt:The batch_scoring.py script takes the following parameters, which get passed from the ParallelRunStep you create later:

  • --model_name: De naam van het model dat wordt gebruikt.--model_name: The name of the model being used.
  • --labels_dir: De locatie van het bestand labels.txt.--labels_dir: The location of the labels.txt file.

De pijplijninfrastructuur gebruikt de klasse ArgumentParser om parameters door te geven aan pijplijnstappen.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. In de volgende code krijgt het eerste argument --model_name bijvoorbeeld de eigenschaps-id model_name.For example, in the following code, the first argument --model_name is given the property identifier model_name. In de functie init() wordt Model.get_model_path(args.model_name) gebruikt om toegang te krijgen tot deze eigenschap.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

Tip

De pijplijn in deze zelfstudie heeft slechts één stap en schrijft de uitvoer naar een bestand.The pipeline in this tutorial has only one step, and it writes the output to a file. Voor pijplijnen met meerdere stappen gebruikt u ook ArgumentParser om een map te definiëren voor het schrijven van uitvoergegevens voor invoer naar volgende stappen.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. Zie de notebook voor een voorbeeld van het doorgeven van gegevens tussen meerdere pijplijnstappen met behulp van het ArgumentParser-ontwerppatroon.For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

De pijplijn bouwenBuild the pipeline

Voordat u de pijplijn uitvoert, maakt u een object dat de Python-omgeving definieert en maakt u de afhankelijkheden die uw batch_scoring.py-script nodig heeft.Before you run the pipeline, create an object that defines the Python environment and creates the dependencies that your batch_scoring.py script requires. De belangrijkste vereiste afhankelijkheid is Tensorflow, maar u installeert ook azureml-core en azureml-dataprep[fuse] die vereist zijn voor ParallelRunStep.The main dependency required is Tensorflow, but you also install azureml-core and azureml-dataprep[fuse] which are required by ParallelRunStep. Geef ook Docker- en Docker-GPU-ondersteuning op.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

De configuratie maken om het script te verpakkenCreate the configuration to wrap the script

Maak de pijplijnstap met het script, de omgevingsconfiguratie en de parameters.Create the pipeline step using the script, environment configuration, and parameters. Geef het rekendoel op dat u al aan uw werkruimte hebt gekoppeld.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
)

De pijplijnstap makenCreate the pipeline step

Een pijplijnstap is een object dat alles inkapselt dat u nodig hebt om een pijplijn uit te voeren, waaronder:A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Omgevings- en afhankelijkheidsinstellingenEnvironment and dependency settings
  • De rekenresource waarmee de pijplijn moet worden uitgevoerdThe compute resource to run the pipeline on
  • Invoer- en uitvoergegevens en eventuele aangepaste parametersInput and output data, and any custom parameters
  • Verwijzing naar een script of SDK-logica om uit te voeren tijdens de stapReference to a script or SDK logic to run during the step

Meerdere klassen worden overgenomen van de bovenliggende klasse PipelineStep.Multiple classes inherit from the parent class PipelineStep. U kunt klassen kiezen om specifieke frameworks of stacks te gebruiken om een stap te maken.You can choose classes to use specific frameworks or stacks to build a step. In dit voorbeeld gebruikt u de klasse ParallelRunStep om uw staplogica te definiëren met behulp van een aangepast Python-script.In this example, you use the ParallelRunStep class to define your step logic by using a custom Python script. Als een argument voor uw script een invoer of een uitvoer is van de stap, moet het argument worden gedefinieerd in zowel de arguments-matrix als in de input- of output-parameter.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 scenario's waarin er meer dan één stap is, wordt een objectverwijzing in de matrix outputs beschikbaar als invoer voor een volgende pijplijnstap.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
)

Voor een lijst met alle klassen die u voor verschillende typen stappen kunt gebruiken, raadpleegt u het stappenpakket.For a list of all the classes you can use for different step types, see the steps package.

De pijplijn indienenSubmit the pipeline

Voer nu de pijplijn uit.Now, run the pipeline. Maak eerst een Pipeline-object met behulp van uw werkruimtereferentie en de pijplijnstap die u hebt gemaakt.First, create a Pipeline object by using your workspace reference and the pipeline step you created. De steps-parameter is een matrix van stappen.The steps parameter is an array of steps. In dit geval is er slechts één stap voor batchgewijs scoren.In this case, there's only one step for batch scoring. Als u pijplijnen met meerdere stappen wilt bouwen, plaatst u de stappen in volgorde in deze matrix.To build pipelines that have multiple steps, place the steps in order in this array.

Gebruik vervolgens de functie Experiment.submit() om de pijplijn te verzenden voor uitvoering.Next, use the Experiment.submit() function to submit the pipeline for execution. De functie wait_for_completion voert logboeken uit tijdens het bouwen van de pijplijn.The wait_for_completion function outputs logs during the pipeline build process. U kunt de logboeken gebruiken om de huidige voortgang te bekijken.You can use the logs to see current progress.

Belangrijk

De eerste pijplijnuitvoering duurt ongeveer 15 minuten.The first pipeline run takes roughly 15 minutes. Alle afhankelijkheden moeten worden gedownload, een Docker-kopie wordt gemaakt en de Python-omgeving wordt ingericht en gemaakt.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. Het opnieuw uitvoeren van de pijplijn vergt aanzienlijk minder tijd, omdat deze resources opnieuw worden gebruikt in plaats van worden gemaakt.Running the pipeline again takes significantly less time because those resources are reused instead of created. De totale runtime voor de pijplijn is echter afhankelijk van de werkbelasting van uw scripts en de processen die in elke pijplijnstap worden uitgevoerd.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, 'batch_scoring').submit(pipeline)
pipeline_run.wait_for_completion(show_output=True)

Uitvoer downloaden en bekijkenDownload and review output

Voer de volgende code uit om het uitvoerbestand te downloaden dat is gemaakt op basis van het batch_scoring.py-script.Run the following code to download the output file that's created from the batch_scoring.py script. Bekijk vervolgens de scoreresultaten.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)

Publiceren en uitvoeren vanaf een REST-eindpuntPublish and run from a REST endpoint

Voer de volgende code uit om de pijplijn te publiceren naar uw werkruimte.Run the following code to publish the pipeline to your workspace. In uw werkruimte in Azure Machine Learning Studio kunt u metagegevens voor de pijplijn zien, inclusief uitvoeringsgeschiedenis en duur.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. U kunt de pijplijn ook handmatig uitvoeren vanuit de Studio.You can also run the pipeline manually from the studio.

Als u de pijplijn publiceert, wordt een REST-eindpunt ingeschakeld dat u kunt gebruiken om de pijplijn uit te voeren vanuit elke HTTP-bibliotheek op elk platform.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

Als u de pijplijn vanuit het REST-eindpunt wilt uitvoeren, hebt u een OAuth2-verificatieheader nodig.To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. In het volgende voorbeeld wordt gebruikgemaakt van interactieve verificatie (ter illustratie), maar voor de meeste productiescenario's waarvoor geautomatiseerde of headless verificatie is vereist, gebruikt u verificatie met de service-principal, zoals beschreven in dit artikel.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.

Voor verificatie met de service-principal moet u een app-registratie maken in Azure Active Directory.Service principal authentication involves creating an App Registration in Azure Active Directory. Eerst genereert u een clientgeheim en vervolgens verleent u uw service-principal roltoegang tot uw machine learning-werkruimte.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Gebruik de ServicePrincipalAuthentication-klasse om uw verificatiestroom te beheren.Use the ServicePrincipalAuthentication class to manage your authentication flow.

Zowel InteractiveLoginAuthentication als ServicePrincipalAuthentication worden overgenomen van AbstractAuthentication.Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. In beide gevallen gebruikt u de functie get_authentication_header() op dezelfde manier om de header op te halen: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()

Haal de REST-URL op uit de eigenschap endpoint van het gepubliceerde pijplijnobject.Get the REST URL from the endpoint property of the published pipeline object. U kunt de REST-URL ook vinden in uw werkruimte in Azure Machine Learning Studio.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Bouw een HTTP POST-aanvraag voor het eindpunt.Build an HTTP POST request to the endpoint. Geef uw verificatieheader op in de aanvraag.Specify your authentication header in the request. Voeg een JSON-payload-object toe met de naam van het experiment.Add a JSON payload object that has the experiment name.

Maak de aanvraag om de uitvoering te activeren.Make the request to trigger the run. Neem code op om toegang te krijgen tot de Id-sleutel vanuit de antwoordbibliotheek om de waarde van de uitvoer-id op te halen.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": "batch_scoring",
                               "ParameterAssignments": {"process_count_per_node": 6}})
run_id = response.json()["Id"]

Gebruik de uitvoer-id om de status van de nieuwe uitvoering te controleren.Use the run ID to monitor the status of the new run. De nieuwe uitvoering heeft nog 10 tot 15 minuten nodig om te voltooien.The new run takes another 10-15 min to finish.

De nieuwe uitvoering ziet er ongeveer hetzelfde uit als de pijplijn die u eerder in de zelfstudie hebt uitgevoerd.The new run will look similar to the pipeline you ran earlier in the tutorial. U kunt ervoor kiezen om niet de volledige uitvoer weer te geven.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["batch_scoring"], run_id)
RunDetails(published_pipeline_run).show()

Resources opschonenClean up resources

Voltooi deze sectie niet als u van plan bent andere Azure Machine Learning-zelfstudies uit te voeren.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Het rekenproces stoppenStop the compute instance

Als u een reken instantie of een notebook-VM hebt gebruikt, stopt u de virtuele machine wanneer u deze niet gebruikt om de kosten te verlagen.If you used a compute instance or Notebook VM, stop the VM when you are not using it to reduce cost.

  1. Selecteer Computein uw werk ruimte.In your workspace, select Compute.

  2. Selecteer de VM in de lijst.From the list, select the VM.

  3. Selecteer stoppen.Select Stop.

  4. Wanneer u klaar bent om de server opnieuw te gebruiken, selecteert u starten.When you're ready to use the server again, select Start.

Alles verwijderenDelete everything

Als u niet van plan bent om gebruik te maken van de resources die u hebt gemaakt, kunt u ze verwijderen zodat er geen kosten voor in rekening worden gebracht:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Selecteer Resourcegroepen in het linkermenu van de Azure-portal.In the Azure portal, in the left menu, select Resource groups.
  2. Selecteer in de lijst met resourcegroepen de resourcegroep die u hebt gemaakt.In the list of resource groups, select the resource group you created.
  3. Selecteer Resourcegroep verwijderen.Select Delete resource group.
  4. Voer de naam van de resourcegroup in.Enter the resource group name. Selecteer vervolgens Verwijderen.Then, select Delete.

U kunt de resourcegroep ook bewaren en slechts één werkruimte verwijderen.You can also keep the resource group but delete a single workspace. Bekijk de eigenschappen van de werkruimte en selecteer vervolgens Verwijderen.Display the workspace properties, and then select Delete.

Volgende stappenNext steps

In deze zelfstudie over machine learning-pijplijnen hebt u het volgende gedaan:In this machine learning pipelines tutorial, you did the following tasks:

  • U hebt een pijplijn met omgevingsafhankelijkheden gebouwd om te worden uitgevoerd op een externe GPU-rekenresource.Built a pipeline with environment dependencies to run on a remote GPU compute resource.
  • U hebt een scoringscript gemaakt voor het uitvoeren van batchgewijze voorspellingen met behulp van een vooraf getraind Tensorflow-model.Created a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • U hebt een pijplijn gepubliceerd en deze ingeschakeld om te worden uitgevoerd vanaf een REST-eindpunt.Published a pipeline and enabled it to be run from a REST endpoint.

Voor meer voorbeelden van het bouwen van pijplijnen met behulp van de machine learning-SDK, raadpleegt u de notebook-opslagplaats.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.