Självstudie: Bygg en Azure Machine Learning pipeline för batch-PoängTutorial: Build an Azure Machine Learning pipeline for batch scoring

gäller för:  Ja Basic Edition  Ja Enterprise Edition                               (Uppgradera till Enterprise Edition) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

I den här avancerade självstudien får du lära dig hur du skapar en pipeline i Azure Machine Learning att köra ett batch-bedömnings jobb.In this advanced tutorial, you learn how to build a pipeline in Azure Machine Learning to run a batch scoring job. Maskin inlärnings pipeliner optimerar arbets flödet med hastighet, portabilitet och åter användning, så att du kan fokusera på maskin inlärning i stället för infrastruktur och automatisering.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on machine learning instead of infrastructure and automation. När du har skapat och publicerat en pipeline konfigurerar du en REST-slutpunkt som du kan använda för att utlösa pipelinen från alla HTTP-bibliotek på vilken plattform som helst.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.

Exemplet använder en förtränad in(convolutionalt neurala - nätverks modell som implementerats i Tensorflow för att klassificera omärkta bilder.The example uses a pretrained Inception-V3 convolutional neural network model implemented in Tensorflow to classify unlabeled images. Läs mer om maskin inlärnings pipeliner.Learn more about machine learning pipelines.

I den här självstudien slutför du följande uppgifter:In this tutorial, you complete the following tasks:

  • Konfigurera arbetsytaConfigure workspace
  • Hämta och lagra exempel dataDownload and store sample data
  • Skapa data mängds objekt för att hämta och mata ut dataCreate dataset objects to fetch and output data
  • Ladda ned, Förbered och registrera modellen på din arbets ytaDownload, prepare, and register the model in your workspace
  • Etablera beräknings mål och skapa ett bedömnings skriptProvision compute targets and create a scoring script
  • Använd ParallelRunStep klassen för asynkron batch-PoängUse the ParallelRunStep class for async batch scoring
  • Skapa, köra och publicera en pipelineBuild, run, and publish a pipeline
  • Aktivera en REST-slutpunkt för pipelinenEnable a REST endpoint for the pipeline

Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.If you don't have an Azure subscription, create a free account before you begin. Prova den kostnads fria eller betalda versionen av Azure Machine Learning idag.Try the free or paid version of Azure Machine Learning today.

FörutsättningarPrerequisites

  • Om du inte redan har en Azure Machine Learning arbets yta eller en virtuell dator i datorn, fyller du i del 1 i installations guiden för.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • När du är klar med installations självstudien använder du samma Notebook-Server för att öppna självstudierna/Machine-Learning-pipelines-Advanced/tutorial-pipeline-batch-scoring-Classification. ipynb Notebook.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.

Om du vill köra själv studie kursen i din egen lokala miljökan du komma åt själv studie kursen om GitHub.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Kör pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests för att hämta de nödvändiga paketen.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests to get the required packages.

Konfigurera arbets ytan och skapa ett data lagerConfigure workspace and create a datastore

Skapa ett objekt för arbets ytan från den befintliga Azure Machine Learning-arbetsytan.Create a workspace object from the existing Azure Machine Learning workspace.

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

Viktigt

Det här kodfragmentet förväntar sig att arbets ytans konfiguration sparas i den aktuella katalogen eller dess överordnade.This code snippet expects the workspace configuration to be saved in the current directory or its parent. Mer information om hur du skapar en arbets yta finns i skapa och hantera Azure Machine Learning arbets ytor.For more information on creating a workspace, see Create and manage Azure Machine Learning workspaces. Mer information om hur du sparar konfigurationen till filen finns i skapa en konfigurations fil för arbets ytor.For more information on saving the configuration to file, see Create a workspace configuration file.

Skapa ett data lager för exempel bilderCreate a datastore for sample images

pipelinedata kontot hämtar du ImageNet för utvärdering av offentliga data från den sampledata offentliga BLOB-behållaren.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Anropa register_azure_blob_container() för att göra data tillgängliga för arbets ytan under namnet images_datastore .Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. Ange sedan standard data lagret för arbets ytan som utdata-datalager.Then, set the workspace default datastore as the output datastore. Använd utdata-datalagret för att räkna ut utdata i pipelinen.Use the output datastore to score output in the pipeline.

Mer information om hur du kommer åt data finns i så här kommer du åt data.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()

Skapa data mängds objektCreate dataset objects

När du skapar pipeliner Dataset används objekt för att läsa data från data lager för arbets ytor och PipelineData objekt används för att överföra mellanliggande data mellan pipeline-steg.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.

Viktigt

I batch-bedömnings exemplet i den här självstudien används endast ett pipeline-steg.The batch scoring example in this tutorial uses only one pipeline step. I användnings fall som har flera steg innehåller det typiska flödet följande steg:In use cases that have multiple steps, the typical flow will include these steps:

  1. Använd Dataset objekt som indata för att hämta rå data, utför en del omvandling och sedan skriva ut ett PipelineData objekt.Use Dataset objects as inputs to fetch raw data, perform some transformation, and then output a PipelineData object.

  2. Använd PipelineData objektet utdata i föregående steg som ett indata-objekt.Use the PipelineData output object in the preceding step as an input object. Upprepa det för efterföljande steg.Repeat it for subsequent steps.

I det här scenariot skapar du Dataset objekt som motsvarar data lager kataloger för både indata och klassificerings etiketter (y-test-värden).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). Du skapar också ett PipelineData objekt för utdata från batch-poängen.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")

Registrera sedan data uppsättningarna på arbets ytan.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")

Hämta och registrera modellenDownload and register the model

Hämta den förtränade Tensorflow-modellen och Använd den för batch-Poäng i en pipeline.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. Skapa först en lokal katalog där du lagrar modellen.First, create a local directory where you store the model. Hämta och extrahera sedan modellen.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")

Registrera sedan modellen på arbets ytan så att du enkelt kan hämta modellen i pipeline-processen.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. I den register() statiska funktionen model_name är parametern den nyckel som du använder för att hitta din modell i SDK: n.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)

Skapa och koppla fjärrberäknings måletCreate and attach the remote compute target

Det går inte att köra maskin inlärnings pipeliner lokalt, så du kör dem på moln resurser eller fjärranslutna beräknings mål.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. Ett fjärran sluten beräknings mål är en återanvändbar virtuell beräknings miljö där du kör experiment och Machine Learning-arbetsflöden.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

Kör följande kod för att skapa ett GPU-aktiverat AmlCompute mål och koppla det sedan till din arbets yta.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. Mer information om beräknings mål finns i den konceptuella artikeln.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)

Skriv ett bedömnings skriptWrite a scoring script

Om du vill göra en bedömning skapar du ett kommando bedömnings skript som heter batch_scoring.py och skriver det sedan till den aktuella katalogen.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. Skriptet använder inmatnings bilder, använder klassificerings modellen och matar sedan ut förutsägelserna till en resultat fil.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

batch_scoring.pySkriptet använder följande parametrar, som skickas från ParallelRunStep dig senare:The batch_scoring.py script takes the following parameters, which get passed from the ParallelRunStep you create later:

  • --model_name: Namnet på den modell som används.--model_name: The name of the model being used.
  • --labels_dir: labels.txt Filens plats.--labels_dir: The location of the labels.txt file.

Pipeline-infrastrukturen använder ArgumentParser klassen för att skicka parametrar till pipeline-steg.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. I följande kod tilldelas till exempel det första argumentet --model_name egenskaps-ID model_name .For example, in the following code, the first argument --model_name is given the property identifier model_name. I init() funktionen Model.get_model_path(args.model_name) används för att få åtkomst till den här egenskapen.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

Tips

Pipelinen i den här självstudien har bara ett steg och skriver utdata till en fil.The pipeline in this tutorial has only one step, and it writes the output to a file. För pipeline i flera steg använder du också ArgumentParser för att definiera en katalog för att skriva utdata som indata för efterföljande steg.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. Ett exempel på att skicka data mellan flera pipeline-steg med hjälp av ArgumentParser design mönstret finns i antecknings boken.For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

Bygg pipelinenBuild the pipeline

Innan du kör pipelinen skapar du ett-objekt som definierar python-miljön och skapar de beroenden som ditt batch_scoring.py skript kräver.Before you run the pipeline, create an object that defines the Python environment and creates the dependencies that your batch_scoring.py script requires. Det nödvändiga huvud beroendet är Tensorflow, men du installerar azureml-core och azureml-dataprep[fuse] som krävs av ParallelRunStep.The main dependency required is Tensorflow, but you also install azureml-core and azureml-dataprep[fuse] which are required by ParallelRunStep. Ange också Docker och Docker-GPU-stöd.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

Skapa konfigurationen för att packa upp skriptetCreate the configuration to wrap the script

Skapa pipeline-steget med skriptet, miljö konfigurationen och parametrarna.Create the pipeline step using the script, environment configuration, and parameters. Ange det beräknings mål som du redan har kopplat till din arbets yta.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="scripts",
    output_action="append_row",
    mini_batch_size="20",
    error_threshold=1,
    compute_target=compute_target,
    process_count_per_node=2,
    node_count=1
)

Skapa pipeline-stegetCreate the pipeline step

Ett pipeline-steg är ett objekt som kapslar in allt du behöver för att köra en pipeline, inklusive:A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Miljö-och beroende inställningarEnvironment and dependency settings
  • Beräknings resursen som ska köra pipelinen påThe compute resource to run the pipeline on
  • Indata och utdata och eventuella anpassade parametrarInput and output data, and any custom parameters
  • Referens till ett skript eller en SDK-logik som ska köras under stegetReference to a script or SDK logic to run during the step

Flera klasser ärver från den överordnade klassen PipelineStep .Multiple classes inherit from the parent class PipelineStep. Du kan välja klasser för att använda specifika ramverk eller stackar för att bygga ett steg.You can choose classes to use specific frameworks or stacks to build a step. I det här exemplet använder du ParallelRunStep klassen för att definiera din steg logik genom att använda ett anpassat Python-skript.In this example, you use the ParallelRunStep class to define your step logic by using a custom Python script. Om ett argument i skriptet antingen är indata till steget eller utdata från steget, måste argumentet definieras både i arguments matrisen och i respektive input 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.

I scenarier där det finns mer än ett steg blir en objekt referens i outputs matrisen tillgänglig som inmatad för ett efterföljande pipeline-steg.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
)

En lista över alla klasser du kan använda för olika steg typer finns i steg paketet.For a list of all the classes you can use for different step types, see the steps package.

Skicka pipelinenSubmit the pipeline

Kör nu pipelinen.Now, run the pipeline. Börja med att skapa ett Pipeline objekt med hjälp av din arbets ytas referens och det pipeline-steg som du skapade.First, create a Pipeline object by using your workspace reference and the pipeline step you created. stepsParametern är en matris med steg.The steps parameter is an array of steps. I det här fallet finns det bara ett steg för batch-poäng.In this case, there's only one step for batch scoring. Placera stegen i den här matrisen för att bygga pipeliner som har flera steg.To build pipelines that have multiple steps, place the steps in order in this array.

Använd sedan Experiment.submit() funktionen för att skicka pipelinen för körning.Next, use the Experiment.submit() function to submit the pipeline for execution. wait_for_completionFunktionen matar ut loggar under pipeline-Bygg processen.The wait_for_completion function outputs logs during the pipeline build process. Du kan använda loggarna för att se aktuell status.You can use the logs to see current progress.

Viktigt

Den första pipeline-körningen tar ungefär 15 minuter.The first pipeline run takes roughly 15 minutes. Alla beroenden måste hämtas, en Docker-avbildning skapas och python-miljön har skapats och skapats.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. Att köra pipelinen igen får betydligt kortare tid eftersom resurserna återanvänds i stället för att skapas.Running the pipeline again takes significantly less time because those resources are reused instead of created. Den totala körnings tiden för pipelinen beror dock på arbets belastningen för dina skript och de processer som körs i varje pipeline-steg.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)

Hämta och granska utdataDownload and review output

Kör följande kod för att ladda ned utdatafilen som skapas från batch_scoring.py skriptet.Run the following code to download the output file that's created from the batch_scoring.py script. Utforska sedan resultat resultaten.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)

Publicera och köra från en REST-slutpunktPublish and run from a REST endpoint

Kör följande kod för att publicera pipelinen till din arbets yta.Run the following code to publish the pipeline to your workspace. I din arbets yta i Azure Machine Learning Studio kan du se metadata för pipelinen, inklusive körnings historik och varaktighet.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. Du kan också köra pipelinen manuellt från Studio.You can also run the pipeline manually from the studio.

Genom att publicera pipelinen kan du använda en REST-slutpunkt som du kan använda för att köra pipelinen från alla HTTP-bibliotek på vilken plattform som helst.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

Om du vill köra pipelinen från REST-slutpunkten behöver du ett OAuth2 Bearer-huvud.To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. I följande exempel används interaktiv autentisering (för illustrations ändamål), men för de flesta produktions scenarier som kräver automatiserad eller riktad autentisering, använder du tjänstens huvud namns autentisering enligt beskrivningen i den här artikeln.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.

Autentisering av tjänstens huvud konto innebär att skapa en app-registrering i Azure Active Directory.Service principal authentication involves creating an App Registration in Azure Active Directory. Först genererar du en klient hemlighet och sedan beviljar du rollen som tjänst huvud namn till din Machine Learning-arbetsyta.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Använd- ServicePrincipalAuthentication klassen för att hantera ditt autentiserings flöde.Use the ServicePrincipalAuthentication class to manage your authentication flow.

Både InteractiveLoginAuthentication och ServicePrincipalAuthentication ärver från AbstractAuthentication .Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. I båda fallen använder du get_authentication_header() funktionen på samma sätt för att hämta rubriken: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()

Hämta REST-URL: en från endpoint egenskapen för det publicerade pipeline-objektet.Get the REST URL from the endpoint property of the published pipeline object. Du kan också hitta REST-URL: en i din arbets yta i Azure Machine Learning Studio.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Bygg en HTTP POST-begäran till slut punkten.Build an HTTP POST request to the endpoint. Ange ditt Authentication-huvud i begäran.Specify your authentication header in the request. Lägg till ett JSON-nyttolast-objekt med experimentets namn.Add a JSON payload object that has the experiment name.

Gör begäran för att utlösa körningen.Make the request to trigger the run. Ta med kod för att komma åt Id nyckeln från svars ord listan för att hämta värdet för körnings-ID: t.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"]

Använd körnings-ID: t för att övervaka statusen för den nya körningen.Use the run ID to monitor the status of the new run. Den nya körningen tar en till 10-15 min för slut.The new run takes another 10-15 min to finish.

Den nya körningen ser ut ungefär som den pipeline du körde tidigare i självstudien.The new run will look similar to the pipeline you ran earlier in the tutorial. Du kan välja att inte Visa hela utdata.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()

Rensa resurserClean up resources

Slutför inte det här avsnittet om du planerar att köra andra Azure Machine Learning själv studie kurser.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Stoppa beräknings instansenStop the compute instance

Om du har använt en beräknings instans eller en VM-dator stoppar du den virtuella datorn när du inte använder den för att minska kostnaderna.If you used a compute instance or Notebook VM, stop the VM when you are not using it to reduce cost.

  1. Välj Compute (beräkna) i arbets ytan.In your workspace, select Compute.

  2. Välj den virtuella datorn i listan.From the list, select the VM.

  3. Välj stoppa.Select Stop.

  4. När du är redo att använda servern igen väljer du Starta.When you're ready to use the server again, select Start.

Ta bort alltDelete everything

Om du inte planerar att använda de resurser som du skapade, tar du bort dem så att du inte debiteras:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. I Azure Portal väljer du resurs grupperpå den vänstra menyn.In the Azure portal, in the left menu, select Resource groups.
  2. I listan över resurs grupper väljer du den resurs grupp som du skapade.In the list of resource groups, select the resource group you created.
  3. Välj Ta bort resursgrupp.Select Delete resource group.
  4. Ange resursgruppsnamnet.Enter the resource group name. Välj sedan ta bort.Then, select Delete.

Du kan också behålla resursgruppen men ta bort en enstaka arbetsyta.You can also keep the resource group but delete a single workspace. Visa egenskaperna för arbets ytan och välj sedan ta bort.Display the workspace properties, and then select Delete.

Nästa stegNext steps

I den här självstudien om maskin inlärning har du följande uppgifter:In this machine learning pipelines tutorial, you did the following tasks:

  • Skapade en pipeline med miljö beroenden som ska köras på en fjärran sluten GPU Compute-resurs.Built a pipeline with environment dependencies to run on a remote GPU compute resource.
  • Skapade ett bedömnings skript för att köra batch-förutsägelser med hjälp av en förtränad Tensorflow-modell.Created a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • Publicerade en pipeline och har aktiverat den för att köras från en REST-slutpunkt.Published a pipeline and enabled it to be run from a REST endpoint.

Fler exempel på hur du skapar pipelines med Machine Learning SDK finns i Notebook-lagringsplatsen.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.