Samouczek: Tworzenie potoku Azure Machine Learning na potrzeby oceniania partiiTutorial: Build an Azure Machine Learning pipeline for batch scoring

W tym zaawansowanym samouczku dowiesz się, jak utworzyć potok Azure Machine Learning , aby uruchomić zadanie oceniania partii.In this advanced tutorial, you learn how to build an Azure Machine Learning pipeline to run a batch scoring job. Potoki uczenia maszynowego optymalizują przepływ pracy z szybkością, przenośnością i wielokrotnym użyciem, dzięki czemu możesz skupić się na uczeniu maszynowym zamiast infrastruktury i automatyzacji.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on machine learning instead of infrastructure and automation. Po skompilowaniu i opublikowaniu potoku należy skonfigurować punkt końcowy REST, za pomocą którego można wyzwolić potok z dowolnej biblioteki HTTP na dowolnej platformie.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.

W przykładzie zastosowano splotowych model sieci neuronowych, który został wdrożony w Tensorflow do klasyfikowania obrazów bez etykiet.The example uses a pretrained Inception-V3 convolutional neural network model implemented in Tensorflow to classify unlabeled images.

W tym samouczku wykonasz następujące zadania:In this tutorial, you complete the following tasks:

  • Konfigurowanie obszaru roboczegoConfigure workspace
  • Pobieranie i przechowywanie przykładowych danychDownload and store sample data
  • Tworzenie obiektów DataSet do pobierania i wyprowadzania danychCreate dataset objects to fetch and output data
  • Pobieranie, przygotowywanie i rejestrowanie modelu w obszarze roboczymDownload, prepare, and register the model in your workspace
  • Udostępnianie elementów docelowych obliczeń i Tworzenie skryptu ocenianiaProvision compute targets and create a scoring script
  • Użyj ParallelRunStep klasy do asynchronicznego oceniania partiiUse the ParallelRunStep class for async batch scoring
  • Kompilowanie, uruchamianie i publikowanie potokuBuild, run, and publish a pipeline
  • Włączanie punktu końcowego REST dla potokuEnable a REST endpoint for the pipeline

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.If you don't have an Azure subscription, create a free account before you begin. Wypróbuj bezpłatną lub płatną wersję Azure Machine Learning dzisiaj.Try the free or paid version of Azure Machine Learning today.

Wymagania wstępnePrerequisites

  • Jeśli nie masz jeszcze Azure Machine Learning obszaru roboczego lub notesu maszyny wirtualnej, Ukończ część 1 samouczka instalacji.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • Po zakończeniu pracy z samouczkiem Instalatora Użyj tego samego serwera notesu, aby otworzyć Notes /Machine-Learning-Pipelines-Advanced/tutorial-Pipeline-Batch-Scoring-Classification. ipynb .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.

Jeśli chcesz uruchomić samouczek instalacji we własnym środowisku lokalnym, możesz uzyskać dostęp do samouczka w witrynie GitHub.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Uruchom, pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests Aby pobrać wymagane pakiety.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests to get the required packages.

Konfigurowanie obszaru roboczego i tworzenie magazynu danychConfigure workspace and create a datastore

Utwórz obiekt obszaru roboczego z istniejącego obszaru roboczego Azure Machine Learning.Create a workspace object from the existing Azure Machine Learning workspace.

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

Ważne

Ten fragment kodu oczekuje, że Konfiguracja obszaru roboczego ma zostać zapisana w bieżącym katalogu lub jego elemencie nadrzędnym.This code snippet expects the workspace configuration to be saved in the current directory or its parent. Aby uzyskać więcej informacji na temat tworzenia obszaru roboczego, zobacz Tworzenie obszarów roboczych i zarządzanie nimi Azure Machine Learning.For more information on creating a workspace, see Create and manage Azure Machine Learning workspaces. Aby uzyskać więcej informacji na temat zapisywania konfiguracji do pliku, zobacz Tworzenie pliku konfiguracji obszaru roboczego.For more information on saving the configuration to file, see Create a workspace configuration file.

Tworzenie magazynu danych dla przykładowych obrazówCreate a datastore for sample images

Na pipelinedata koncie Pobierz przykład danych z publicznej oceny ImageNet z sampledata publicznego kontenera obiektów BLOB.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Wywołaj, register_azure_blob_container() Aby udostępnić dane dla obszaru roboczego pod nazwą images_datastore .Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. Następnie należy ustawić domyślny magazyn danych obszaru roboczego jako wyjściowy.Then, set the workspace default datastore as the output datastore. Użyj wyjściowego magazynu danych do oceny danych wyjściowych w potoku.Use the output datastore to score output in the pipeline.

Aby uzyskać więcej informacji na temat uzyskiwania dostępu do danych, zobacz jak uzyskać dostęp do danych.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()

Tworzenie obiektów DataSetCreate dataset objects

Podczas kompilowania potoków Dataset obiekty są używane do odczytywania danych z magazynów elementów obszaru roboczego, a OutputFileDatasetConfig obiekty są używane do przesyłania danych pośrednich między etapami potoku.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.

Ważne

Przykład wsadowego oceniania w tym samouczku używa tylko jednego kroku potoku.The batch scoring example in this tutorial uses only one pipeline step. W przypadku użycia, które mają wiele kroków, typowy przepływ obejmuje następujące kroki:In use cases that have multiple steps, the typical flow will include these steps:

  1. Użyj Dataset obiektów jako danych wejściowych , aby pobrać dane pierwotne, wykonać transformację, a następnie dane wyjściowe z OutputFileDatasetConfig obiektem.Use Dataset objects as inputs to fetch raw data, perform some transformation, and then output with an OutputFileDatasetConfig object.

  2. Użyj OutputFileDatasetConfig obiektu wyjściowego w poprzednim kroku jako obiektu wejściowego.Use the OutputFileDatasetConfig output object in the preceding step as an input object. Powtórz tę czynność dla kolejnych kroków.Repeat it for subsequent steps.

W tym scenariuszu utworzysz Dataset obiekty odpowiadające katalogom magazynu danych zarówno dla obrazów wejściowych, jak i etykiet klasyfikacji (wartości y-test).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). Tworzony jest również OutputFileDatasetConfig obiekt dla danych wyjściowych oceniania partii.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")

Zarejestruj zestawy danych w obszarze roboczym, jeśli chcesz użyć go później.Register the datasets to the workspace if you want to reuse it later. Ta czynność jest opcjonalna.This step is optional.


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

Pobieranie i rejestrowanie modeluDownload and register the model

Pobierz Tensorflow model, aby użyć go do oceniania partii w potoku.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. Najpierw Utwórz katalog lokalny, w którym jest przechowywany model.First, create a local directory where you store the model. Następnie pobierz i Wyodrębnij 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")

Następnie zarejestruj model w obszarze roboczym, aby można było łatwo pobrać model w procesie potoku.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. W register() funkcji statycznej model_name parametr jest kluczem używanym do lokalizowania modelu w całym zestawie SDK.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)

Tworzenie i dołączanie zdalnego celu obliczeńCreate and attach the remote compute target

Potoki usługi Machine Learning nie mogą być uruchamiane lokalnie, dlatego można je uruchamiać w zasobach w chmurze lub zdalnych celach obliczeniowych.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. Zdalny obiekt docelowy obliczeń to wirtualne środowisko obliczeniowe wielokrotnego użytku, w którym można uruchamiać eksperymenty i przepływy pracy uczenia maszynowego.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

Uruchom następujący kod, aby utworzyć obiekt docelowy z obsługą procesora GPU AmlCompute , a następnie dołącz go do obszaru roboczego.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. Aby uzyskać więcej informacji na temat obiektów docelowych obliczeń, zobacz artykuł koncepcyjny.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)

Napisz skrypt ocenianiaWrite a scoring script

Aby wykonać ocenianie, Utwórz skrypt oceniania partii o nazwie batch_scoring.py , a następnie zapisz go w bieżącym katalogu.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. Skrypt pobiera obrazy wejściowe, stosuje model klasyfikacji, a następnie wyprowadza przewidywania do pliku wyników.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

batch_scoring.pySkrypt przyjmuje następujące parametry, które ParallelRunStep zostały przesłane później:The batch_scoring.py script takes the following parameters, which get passed from the ParallelRunStep you create later:

  • --model_name: Nazwa używanego modelu.--model_name: The name of the model being used.
  • --labels_dir: Lokalizacja labels.txt pliku.--labels_dir: The location of the labels.txt file.

Infrastruktura potoku używa ArgumentParser klasy do przekazywania parametrów do kroków potoku.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. Na przykład w poniższym kodzie jako pierwszy argument --model_name jest przyznany identyfikator właściwości model_name .For example, in the following code, the first argument --model_name is given the property identifier model_name. W init() funkcji Model.get_model_path(args.model_name) służy do uzyskiwania dostępu do tej właściwości.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

Porada

Potok w tym samouczku ma tylko jeden krok i zapisuje dane wyjściowe do pliku.The pipeline in this tutorial has only one step, and it writes the output to a file. W przypadku potoków wieloetapowych można również ArgumentParser zdefiniować katalog do zapisywania danych wyjściowych do kolejnych kroków.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. Przykład przekazywania danych między wieloma krokami potoku przy użyciu ArgumentParser wzorca projektowego można znaleźć w notesie.For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

Kompilowanie potokuBuild the pipeline

Przed uruchomieniem potoku Utwórz obiekt, który definiuje środowisko Python i tworzy zależności batch_scoring.py wymagane przez skrypt.Before you run the pipeline, create an object that defines the Python environment and creates the dependencies that your batch_scoring.py script requires. Główna zależność wymagana to Tensorflow, ale również instalacja azureml-core i azureml-dataprep[fuse] wymagane przez ParallelRunStep.The main dependency required is Tensorflow, but you also install azureml-core and azureml-dataprep[fuse] which are required by ParallelRunStep. Należy również określić obsługę platformy Docker i platformy Docker-GPU.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

Utwórz konfigurację, aby otoczyć skryptCreate the configuration to wrap the script

Utwórz krok potoku przy użyciu skryptu, konfiguracji środowiska i parametrów.Create the pipeline step using the script, environment configuration, and parameters. Określ miejsce docelowe obliczeń, które zostało już dołączone do obszaru roboczego.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
)

Tworzenie kroku potokuCreate the pipeline step

Krok potoku to obiekt, który hermetyzuje wszystko, czego potrzebujesz do uruchomienia potoku, w tym:A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Ustawienia środowiska i zależnościEnvironment and dependency settings
  • Zasób obliczeniowy, na którym ma zostać uruchomiony potokThe compute resource to run the pipeline on
  • Dane wejściowe i wyjściowe oraz dowolne parametry niestandardoweInput and output data, and any custom parameters
  • Odwołanie do skryptu lub logiki zestawu SDK do uruchomienia w ramach tego krokuReference to a script or SDK logic to run during the step

Wiele klas dziedziczy z klasy nadrzędnej PipelineStep .Multiple classes inherit from the parent class PipelineStep. Możesz wybrać klasy do użycia określonych platform lub stosów, aby skompilować krok.You can choose classes to use specific frameworks or stacks to build a step. W tym przykładzie użyto ParallelRunStep klasy do zdefiniowania logiki krokowej przy użyciu niestandardowego skryptu języka Python.In this example, you use the ParallelRunStep class to define your step logic by using a custom Python script. Jeśli argument skryptu jest danymi wejściowymi do kroku lub danych wyjściowych kroku, argument musi być zdefiniowany zarówno w arguments tablicy, jak i w input lub jako output parametr.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.

W scenariuszach, w których występuje więcej niż jeden krok, odwołanie do obiektu w outputs tablicy jest dostępne jako dane wejściowe dla kolejnego kroku potoku.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
)

Aby zapoznać się z listą wszystkich klas, których można użyć dla różnych typów etapów, zobacz pakiet kroków.For a list of all the classes you can use for different step types, see the steps package.

Prześlij potokSubmit the pipeline

Teraz uruchom potok.Now, run the pipeline. Najpierw Utwórz Pipeline obiekt za pomocą odwołania do obszaru roboczego i utworzonego etapu potoku.First, create a Pipeline object by using your workspace reference and the pipeline step you created. stepsParametr jest tablicą kroków.The steps parameter is an array of steps. W takim przypadku istnieje tylko jeden krok oceniania partii.In this case, there's only one step for batch scoring. Aby utworzyć potoki, które mają wiele kroków, należy umieścić kroki w kolejności w tej tablicy.To build pipelines that have multiple steps, place the steps in order in this array.

Następnie użyj funkcji, Experiment.submit() Aby przesłać potok do wykonania.Next, use the Experiment.submit() function to submit the pipeline for execution. wait_for_completionFunkcja wyprowadza dzienniki podczas procesu kompilacji potoku.The wait_for_completion function outputs logs during the pipeline build process. Możesz użyć dzienników, aby zobaczyć bieżący postęp.You can use the logs to see current progress.

Ważne

Pierwsze uruchomienie potoku trwa około 15 minut.The first pipeline run takes roughly 15 minutes. Wszystkie zależności muszą zostać pobrane, zostanie utworzony obraz platformy Docker, a środowisko Python jest inicjowane i tworzone.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. Ponowne uruchomienie potoku trwa znacznie mniej czasu, ponieważ te zasoby są ponownie używane zamiast tworzenia.Running the pipeline again takes significantly less time because those resources are reused instead of created. Jednak łączny czas wykonywania potoku zależy od obciążenia skryptów i procesów uruchomionych w każdym kroku potoku.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)

Pobierz i Przejrzyj dane wyjścioweDownload and review output

Uruchom następujący kod, aby pobrać plik wyjściowy, który został utworzony ze batch_scoring.py skryptu.Run the following code to download the output file that's created from the batch_scoring.py script. Następnie przejrzyj wyniki oceniania.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)

Publikowanie i uruchamianie z punktu końcowego RESTPublish and run from a REST endpoint

Uruchom następujący kod, aby opublikować potok w obszarze roboczym.Run the following code to publish the pipeline to your workspace. W obszarze roboczym programu Azure Machine Learning Studio można zobaczyć metadane dla potoku, w tym historię uruchamiania i czas trwania.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. Potok można również uruchomić ręcznie z poziomu programu Studio.You can also run the pipeline manually from the studio.

Opublikowanie potoku umożliwia punkt końcowy REST, którego można użyć do uruchomienia potoku z dowolnej biblioteki HTTP na dowolnej platformie.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

Aby można było uruchomić potok z punktu końcowego REST, potrzebny jest nagłówek uwierzytelniania typu "OAuth2".To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. W poniższym przykładzie użyto uwierzytelniania interaktywnego (w celach ilustracyjnych), ale w przypadku większości scenariuszy produkcyjnych, które wymagają automatycznego lub bezobsługowego uwierzytelniania, należy użyć uwierzytelniania nazwy głównej usługi zgodnie z opisem w tym artykule.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.

Uwierzytelnianie jednostki usługi polega na utworzeniu rejestracji aplikacji w Azure Active Directory.Service principal authentication involves creating an App Registration in Azure Active Directory. Najpierw należy wygenerować klucz tajny klienta, a następnie przyznać roli głównej usługi dostęp do obszaru roboczego uczenia maszynowego.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Użyj ServicePrincipalAuthentication klasy, aby zarządzać przepływem uwierzytelniania.Use the ServicePrincipalAuthentication class to manage your authentication flow.

Oba InteractiveLoginAuthentication i ServicePrincipalAuthentication dziedziczą z AbstractAuthentication .Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. W obu przypadkach należy użyć get_authentication_header() funkcji w taki sam sposób, aby można było pobrać nagłówek: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()

Pobierz adres URL REST z endpoint Właściwości opublikowanego obiektu potoku.Get the REST URL from the endpoint property of the published pipeline object. Możesz również znaleźć adres URL REST w obszarze roboczym w programie Azure Machine Learning Studio.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Kompiluj żądanie HTTP POST do punktu końcowego.Build an HTTP POST request to the endpoint. Określ w żądaniu nagłówek uwierzytelniania.Specify your authentication header in the request. Dodaj obiekt ładunku JSON, który ma nazwę eksperymentu.Add a JSON payload object that has the experiment name.

Wykonaj żądanie, aby wyzwolić uruchomienie.Make the request to trigger the run. Dołącz kod, aby uzyskać dostęp do Id klucza z słownika odpowiedzi, aby uzyskać wartość identyfikatora uruchomienia.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"]

Użyj identyfikatora uruchomienia, aby monitorować stan nowego przebiegu.Use the run ID to monitor the status of the new run. Nowy przebieg zajmie jeszcze 10-15 min.The new run takes another 10-15 min to finish.

Nowy przebieg będzie wyglądał podobnie do potoku, który został uruchomiony wcześniej w samouczku.The new run will look similar to the pipeline you ran earlier in the tutorial. Możesz zrezygnować z wyświetlania pełnych danych wyjściowych.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()

Czyszczenie zasobówClean up resources

Nie Dokończ tej sekcji, jeśli planujesz uruchamiać inne samouczki Azure Machine Learning.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Zatrzymaj wystąpienie obliczenioweStop the compute instance

Jeśli używasz wystąpienia obliczeniowego lub maszyny wirtualnej z notesem, Zatrzymaj maszynę wirtualną, gdy nie używasz jej do obniżenia kosztów.If you used a compute instance or Notebook VM, stop the VM when you aren't using it to reduce cost.

  1. W obszarze roboczym wybierz pozycję obliczenia.In your workspace, select Compute.

  2. Z listy wybierz maszynę wirtualną.From the list, select the VM.

  3. Wybierz pozycję Zatrzymaj.Select Stop.

  4. Gdy wszystko będzie gotowe do korzystania z serwera, wybierz pozycję Uruchom.When you're ready to use the server again, select Start.

Usuń wszystkoDelete everything

Jeśli nie planujesz używać utworzonych zasobów, usuń je, aby uniknąć naliczania opłat.If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. W Azure Portal w menu po lewej stronie wybierz pozycję grupy zasobów.In the Azure portal, in the left menu, select Resource groups.
  2. Z listy grup zasobów wybierz utworzoną grupę zasobów.In the list of resource groups, select the resource group you created.
  3. Wybierz pozycję Usuń grupę zasobów.Select Delete resource group.
  4. Wpisz nazwę grupy zasobów.Enter the resource group name. Następnie wybierz pozycję Usuń.Then, select Delete.

Możesz też zachować grupę zasobów i usunąć jeden obszar roboczy.You can also keep the resource group but delete a single workspace. Wyświetl właściwości obszaru roboczego, a następnie wybierz pozycję Usuń.Display the workspace properties, and then select Delete.

Następne krokiNext steps

W tym samouczku potoki uczenia maszynowego zostały wykonane następujące zadania:In this machine learning pipelines tutorial, you did the following tasks:

  • Utworzono potok z zależnościami środowiska do uruchomienia na zdalnym zasobie obliczeniowym procesora GPU.Built a pipeline with environment dependencies to run on a remote GPU compute resource.
  • Utworzono skrypt oceniania służący do uruchamiania prognoz wsadowych przy użyciu przedniego Tensorflow modelu.Created a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • Opublikowano potok i włączył go do uruchamiania z punktu końcowego REST.Published a pipeline and enabled it to be run from a REST endpoint.

Aby uzyskać więcej przykładów tworzenia potoków przy użyciu zestawu SDK usługi Machine Learning, zobacz repozytorium notesu.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.