Tutoriel : Créer un pipeline Azure Machine Learning pour le scoring par lotsTutorial: Build an Azure Machine Learning pipeline for batch scoring

S’APPLIQUE À : ouiÉdition de base ouiÉdition Entreprise                    (Mise à niveau vers l’édition Entreprise)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Dans ce tutoriel avancé, vous allez découvrir comment créer un pipeline Azure Machine Learning pour exécuter un travail de scoring par lots.In this advanced tutorial, you learn how to build a pipeline in Azure Machine Learning to run a batch scoring job. Les pipelines Machine Learning optimisent votre workflow à divers niveaux : vitesse, portabilité et réutilisation. Ainsi, vous pouvez vous concentrer sur le Machine Learning, plutôt que sur l’infrastructure et l’automatisation.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on machine learning instead of infrastructure and automation. Après avoir créé et publié un pipeline, vous configurez un point de terminaison REST qui vous permet de déclencher ce pipeline à partir de n’importe quelle bibliothèque HTTP sur n’importe quelle plateforme.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.

L’exemple utilise un modèle de réseau neuronal convolutif Inception-V3 préentraîné implémenté dans Tensorflow pour classifier les images sans étiquette.The example uses a pretrained Inception-V3 convolutional neural network model implemented in Tensorflow to classify unlabeled images. En savoir plus sur les pipelines Machine Learning.Learn more about machine learning pipelines.

Dans ce tutoriel, vous allez effectuer les tâches suivantes :In this tutorial, you complete the following tasks:

  • Configurer l’espace de travailConfigure workspace
  • Télécharger et stocker des exemples de donnéesDownload and store sample data
  • Créer des objets de jeu de données pour extraire et sortir des donnéesCreate dataset objects to fetch and output data
  • Télécharger, préparer et inscrire le modèle dans votre espace de travailDownload, prepare, and register the model in your workspace
  • Provisionner des cibles de calcul et créer un script de scoringProvision compute targets and create a scoring script
  • Utiliser la classe ParallelRunStep pour le calcul pour le scoring par mot asynchroneUse the ParallelRunStep class for async batch scoring
  • Créer, exécuter et publier un pipelineBuild, run, and publish a pipeline
  • Activer un point de terminaison REST pour le pipelineEnable a REST endpoint for the pipeline

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.If you don't have an Azure subscription, create a free account before you begin. Essayez la version gratuite ou payante d’Azure Machine Learning dès aujourd’hui.Try the free or paid version of Azure Machine Learning today.

PrérequisPrerequisites

  • Si vous n’avez pas encore d’espace de travail Azure Machine Learning ou de machine virtuelle de notebook, effectuez la Partie 1 du tutoriel d’installation.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • Une fois le tutoriel d’installation effectué, utilisez le même serveur de notebooks pour ouvrir le notebook tutorials/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.

Si vous souhaitez suivre le tutoriel d’installation dans votre propre environnement local, vous pouvez y accéder sur GitHub.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Exécutez pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-contrib-pipeline-steps pandas requests pour vous procurer les packages requis.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-contrib-pipeline-steps pandas requests to get the required packages.

Configurer l’espace de travail et créer un magasin de donnéesConfigure workspace and create a datastore

Créez un objet d’espace de travail à partir de l’espace de travail Azure Machine Learning existant.Create a workspace object from the existing Azure Machine Learning workspace.

  • Un espace de travail est une classe qui accepte les informations concernant vos abonnements et ressources Azure.A workspace is a class that accepts your Azure subscription and resource information. L’espace de travail crée également une ressource cloud qui vous permet de superviser et de suivre les exécutions de votre modèle.The workspace also creates a cloud resource you can use to monitor and track your model runs.
  • Workspace.from_config() lit le fichier config.json, puis charge les informations d’authentification dans un objet nommé ws.Workspace.from_config() reads the config.json file and then loads the authentication details into an object named ws. L’objet ws est utilisé dans le code tout au long de ce tutoriel.The ws object is used in the code throughout this tutorial.
from azureml.core import Workspace
ws = Workspace.from_config()

Créer une banque de données pour des exemples d’imagesCreate a datastore for sample images

Pour le compte pipelinedata, récupérez l’exemple de données publiques d’évaluation ImageNet à partir du conteneur d’objets blob public sampledata.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Appelez register_azure_blob_container() pour rendre les données disponibles dans l’espace de travail sous le nom images_datastore.Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. Définissez ensuite le magasin de données par défaut de l’espace de travail en tant que magasin de données de sortie.Then, set the workspace default datastore as the output datastore. Utilisez le magasin de données de sortie pour effectuer un scoring de la sortie dans le pipeline.Use the output datastore to score output in the pipeline.

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

Créer des objets de jeu de donnéesCreate dataset objects

Durant la création de pipelines, les objets Dataset sont utilisés pour lire les données des banques de données d’espace de travail, et les objets PipelineData sont utilisés pour transférer les données intermédiaires entre les étapes de pipeline.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.

Important

L’exemple de scoring par lots de ce tutoriel utilise une seule étape de pipeline.The batch scoring example in this tutorial uses only one pipeline step. Dans les cas d’usage qui comportent plusieurs étapes, le flux classique inclut les étapes suivantes :In use cases that have multiple steps, the typical flow will include these steps:

  1. Utilisez des objets Dataset en tant qu’entrées pour extraire les données brutes, exécutez certaines transformations, puis effectuez la sortie d’un objet PipelineData.Use Dataset objects as inputs to fetch raw data, perform some transformation, and then output a PipelineData object.

  2. Utilisez l’objet de sortie PipelineData de l’étape précédente en tant qu’objet d’entrée.Use the PipelineData output object in the preceding step as an input object. Répétez cette opération pour les étapes suivantes.Repeat it for subsequent steps.

Dans ce scénario, vous créez des objets Dataset qui correspondent aux répertoires de magasin de données pour les images d’entrée et les étiquettes de classification (valeurs de test y).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). Vous créez également un objet PipelineData pour les données de sortie du scoring par lots.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/*.txt"))
output_dir = PipelineData(name="scores", 
                          datastore=def_data_store, 
                          output_path_on_compute="batchscoring/results")

Ensuite, inscrivez les jeux de données dans l’espace de travail.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")

Télécharger et inscrire le modèleDownload and register the model

Téléchargez le modèle Tensorflow préentraîné afin de l’utiliser pour le scoring par lots dans un pipeline.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. Commencez par créer un répertoire local où stocker le modèle.First, create a local directory where you store the model. Téléchargez et extrayez ensuite le modèle.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")

Inscrivez ensuite le modèle auprès de votre espace de travail pour pouvoir le récupérer facilement dans le processus de pipeline.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. Dans la fonction statique register(), le paramètre model_name représente la clé à utiliser pour localiser votre modèle dans le kit 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)

Créer et attacher la cible de calcul distanteCreate and attach the remote compute target

Vous ne pouvez pas exécuter les pipelines Machine Learning localement, donc exécutez-les sur des ressources cloud ou des cibles de calcul distantes.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. Une cible de calcul distante est un environnement Compute virtuel réutilisable où vous exécutez des expériences et des workflows Machine Learning.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

Exécutez le code suivant pour créer une cible AmlCompute ayant un GPU, puis attachez-la à votre espace de travail.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. Pour plus d’informations sur les cibles de calcul, consultez l’article conceptuel.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)

Écrire un script de scoringWrite a scoring script

Pour effectuer le scoring, créez un script de scoring par lots nommé batch_scoring.py dans le répertoire actif.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. Le script accepte les images d’entrée, applique le modèle de classification, puis génère les prédictions dans un fichier de résultats.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

Le script batch_scoring.py prend les paramètres suivants, qui sont passés à partir de ParallelRunStep que vous allez créer plus loin :The batch_scoring.py script takes the following parameters, which get passed from the ParallelRunStep you create later:

  • --model_name: Nom du modèle utilisé.--model_name: The name of the model being used.
  • --labels_name: Nom du Dataset qui contient le fichier labels.txt.--labels_name: The name of the Dataset that holds the labels.txt file.

L’infrastructure de pipeline utilise la classe ArgumentParser pour passer les paramètres aux étapes de pipeline.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. Par exemple, dans le code suivant, le premier argument --model_name reçoit l’identificateur de propriété model_name.For example, in the following code, the first argument --model_name is given the property identifier model_name. Dans la fonction init(), Model.get_model_path(args.model_name) permet d’accéder à cette propriété.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():
    label = []
    proto_as_ascii_lines = tf.gfile.GFile("labels.txt").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_name', dest="labels_name", required=True)
    args, _ = parser.parse_known_args()

    workspace = Run.get_context(allow_offline=False).experiment.workspace
    label_ds = Dataset.get_by_name(workspace=workspace, name=args.labels_name)
    label_ds.download(target_path='.', overwrite=True)

    label_dict = get_class_label_dict()
    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

Conseil

Le pipeline de ce tutoriel comporte une seule étape et écrit la sortie dans un fichier.The pipeline in this tutorial has only one step, and it writes the output to a file. Pour les pipelines multiétapes, ArgumentParser vous permet également de définir un répertoire où écrire les données de sortie à entrer dans les étapes suivantes.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. Pour obtenir un exemple de passage de données entre plusieurs étapes de pipeline à l’aide du modèle de conception ArgumentParser, consultez le notebook.For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

Générer le pipelineBuild the pipeline

Avant d’exécuter le pipeline, créez un objet qui définit l’environnement Python et crée les dépendances nécessaires à votre script batch_scoring.py.Before you run the pipeline, create an object that defines the Python environment and creates the dependencies that your batch_scoring.py script requires. La dépendance principale nécessaire est Tensorflow, mais vous installez aussi azureml-defaults pour les processus en arrière-plan.The main dependency required is Tensorflow, but you also install azureml-defaults for background processes. Créez un objet RunConfiguration à l’aide des dépendances.Create a RunConfiguration object by using the dependencies. Spécifiez également la prise en charge de Docker et 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.13.1", "azureml-defaults"])
env = Environment(name="parallelenv")
env.python.conda_dependencies = cd
env.docker.base_image = DEFAULT_GPU_IMAGE

Créer la configuration pour encapsuler le scriptCreate the configuration to wrap the script

Créez l’étape du pipeline à l’aide du script, de la configuration de l’environnement et des paramètres.Create the pipeline step using the script, environment configuration, and parameters. Spécifiez la cible de calcul que vous avez déjà attachée à votre espace de travail.Specify the compute target you already attached to your workspace.

from azureml.contrib.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
)

Créer l’étape du pipelineCreate the pipeline step

Une étape de pipeline est un objet qui encapsule tout ce dont vous avez besoin pour exécuter un pipeline, notamment :A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Paramètres d’environnement et de dépendanceEnvironment and dependency settings
  • Ressource de calcul où exécuter le pipelineThe compute resource to run the pipeline on
  • Données d’entrée et de sortie ainsi que tous les paramètres personnalisésInput and output data, and any custom parameters
  • Référence à un script ou une logique de kit SDK à exécuter au cours de l’étapeReference to a script or SDK logic to run during the step

Plusieurs classes héritent de la classe parente PipelineStep.Multiple classes inherit from the parent class PipelineStep. Vous pouvez choisir des classes pour utiliser des frameworks ou des piles spécifiques afin de créer une étape.You can choose classes to use specific frameworks or stacks to build a step. Dans cet exemple, vous utilisez la classe ParallelRunStep pour définir la logique de votre étape en utilisant un script Python personnalisé.In this example, you use the ParallelRunStep class to define your step logic by using a custom Python script. Si un argument de votre script est une entrée ou une sortie de l’étape, il doit être défini à la fois dans le tableau argumentsainsi que dans le paramètre input ou output, respectivement.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.

Dans les scénarios qui comportent plusieurs étapes, une référence d’objet dans le tableau outputs devient disponible en tant qu’entrée pour une étape de pipeline suivante.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.contrib.pipeline.steps import ParallelRunStep

batch_score_step = ParallelRunStep(
    name="parallel-step-test",
    inputs=[input_images.as_named_input("input_images")],
    output=output_dir,
    models=[model],
    arguments=["--model_name", "inception",
               "--labels_name", "label_ds"],
    parallel_run_config=parallel_run_config,
    allow_reuse=False
)

Pour obtenir la liste de toutes les classes utilisables dans les différents types d’étape, consultez les informations relatives au package d’étapes.For a list of all the classes you can use for different step types, see the steps package.

Envoyer le pipelineSubmit the pipeline

À présent, exécutez le pipeline.Now, run the pipeline. Commencez par créer un objet Pipeline en utilisant votre référence d’espace de travail et l’étape de pipeline que vous avez créée.First, create a Pipeline object by using your workspace reference and the pipeline step you created. Le paramètre steps est un tableau d’étapes.The steps parameter is an array of steps. Dans le cas présent, le scoring par lots ne comporte qu’une seule étape.In this case, there's only one step for batch scoring. Pour créer des pipelines qui comportent plusieurs étapes, placez ces dernières dans l’ordre dans ce tableau.To build pipelines that have multiple steps, place the steps in order in this array.

Utilisez ensuite la fonction Experiment.submit() pour soumettre l’exécution du pipeline.Next, use the Experiment.submit() function to submit the pipeline for execution. Vous spécifiez également le paramètre personnalisé param_batch_size.You also specify the custom parameter param_batch_size. La fonction wait_for_completion génère des journaux durant le processus de création du pipeline.The wait_for_completion function outputs logs during the pipeline build process. Vous pouvez utiliser les journaux pour voir la progression actuelle.You can use the logs to see current progress.

Important

La première exécution du pipeline prend environ 15 minutes.The first pipeline run takes roughly 15 minutes. Toutes les dépendances doivent être téléchargées, une image Docker est créée, et l’environnement Python est provisionné et créé.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. La réexécution du pipeline prend beaucoup moins de temps, car ces ressources sont réutilisées au lieu d’être créées.Running the pipeline again takes significantly less time because those resources are reused instead of created. Toutefois, le temps total d’exécution du pipeline dépend de la charge de travail de vos scripts et des processus qui s’exécutent à chaque étape du pipeline.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)

Télécharger et passer en revue la sortieDownload and review output

Exécutez le code suivant pour télécharger le fichier de sortie créé à partir du script batch_scoring.py.Run the following code to download the output file that's created from the batch_scoring.py script. Examinez ensuite les résultats du scoring.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)

Publier et exécuter à partir d’un point de terminaison RESTPublish and run from a REST endpoint

Exécutez le code suivant pour publier le pipeline sur votre espace de travail.Run the following code to publish the pipeline to your workspace. Dans votre espace de travail dans Azure Machine Learning Studio, vous pouvez voir les métadonnées du pipeline, notamment l’historique des exécutions et leurs durées.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. Vous pouvez également exécuter le pipeline manuellement à partir du studio.You can also run the pipeline manually from the studio.

La publication du pipeline active un point de terminaison REST qui vous permet de réexécuter le pipeline à partir de n’importe quelle bibliothèque HTTP sur n’importe quelle plateforme.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

Pour exécuter le pipeline à partir du point de terminaison REST, vous avez besoin d’un en-tête d’authentification de type porteur OAuth2.To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. L’exemple suivant utilise l’authentification interactive (à des fins d’illustration). Toutefois, dans la plupart des scénarios de production qui nécessitent une authentification automatisée ou sans assistance, utilisez l’authentification du principal de service, comme décrit dans cet article.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.

Pour permettre l’authentification du principal de service, créez une inscription d’application dans Azure Active Directory.Service principal authentication involves creating an App Registration in Azure Active Directory. Commencez par générer un secret client, puis accordez au principal de service un accès en fonction du rôle à votre espace de travail Machine Learning.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Utilisez la classe ServicePrincipalAuthentication pour gérer votre flux d’authentification.Use the ServicePrincipalAuthentication class to manage your authentication flow.

InteractiveLoginAuthentication et ServicePrincipalAuthentication héritent de AbstractAuthentication.Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. Dans les deux cas, utilisez la fonction get_authentication_header() de la même manière pour extraire l’en-tête :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()

Obtenez l’URL REST de la propriété endpoint de l’objet de pipeline publié.Get the REST URL from the endpoint property of the published pipeline object. Vous pouvez également trouver l’URL REST dans votre espace de travail dans Azure Machine Learning Studio.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Créez une requête HTTP POST au point de terminaison.Build an HTTP POST request to the endpoint. Spécifiez votre en-tête d’authentification dans la requête.Specify your authentication header in the request. Ajoutez un objet de charge utile JSON ayant le nom de l’expérience et le paramètre de taille de lot.Add a JSON payload object that has the experiment name and the batch size parameter. Comme indiqué plus tôt dans le tutoriel, param_batch_size est passé à votre script batch_scoring.py, car vous l’avez défini en tant qu’objet PipelineParameter dans la configuration de l’étape.As noted earlier in the tutorial, param_batch_size is passed through to your batch_scoring.py script because you defined it as a PipelineParameter object in the step configuration.

Exécutez la requête pour déclencher l’exécution.Make the request to trigger the run. Incluez le code permettant d’accéder à la clé Id à partir du dictionnaire de réponses pour obtenir la valeur de l’ID d’exécution.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": {"param_batch_size": 50}})
run_id = response.json()["Id"]

Utilisez l’ID d’exécution pour superviser l’état de la nouvelle exécution.Use the run ID to monitor the status of the new run. La nouvelle exécution prend à nouveau 10 à 15 minutes pour s’achever.The new run takes another 10-15 min to finish.

La nouvelle exécution va ressembler au pipeline que vous avez exécuté dans le tutoriel.The new run will look similar to the pipeline you ran earlier in the tutorial. Vous pouvez choisir de ne pas voir la sortie complète.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()

Nettoyer les ressourcesClean up resources

Sautez cette section si vous prévoyez de suivre d’autres tutoriels Azure Machine Learning.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Arrêter l’instance de calculStop the compute instance

Si vous avez utilisé une instance de calcul ou une machine virtuelle Notebook, arrêtez la machine virtuelle lorsque vous ne l’utilisez pas afin de réduire les coûts.If you used a compute instance or Notebook VM, stop the VM when you are not using it to reduce cost.

  1. Dans votre espace de travail, sélectionnez Capacité de calcul.In your workspace, select Compute.

  2. Sélectionnez la machine virtuelle dans la liste.From the list, select the VM.

  3. Sélectionnez Arrêter.Select Stop.

  4. Quand vous êtes prêt à utiliser à nouveau le serveur, sélectionnez Démarrer.When you're ready to use the server again, select Start.

Tout supprimerDelete everything

Si vous n’avez pas l’intention d’utiliser les ressources que vous avez créées, supprimez-les pour éviter des frais :If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Dans le portail Azure, dans le menu de gauche, sélectionnez Groupes de ressources.In the Azure portal, in the left menu, select Resource groups.
  2. Dans la liste des groupes de ressources, sélectionnez le groupe de ressources que vous avez créé.In the list of resource groups, select the resource group you created.
  3. Sélectionnez Supprimer le groupe de ressources.Select Delete resource group.
  4. Entrez le nom du groupe de ressources.Enter the resource group name. Ensuite, sélectionnez Supprimer.Then, select Delete.

Vous pouvez également conserver le groupe de ressources mais supprimer un espace de travail unique.You can also keep the resource group but delete a single workspace. Affichez les propriétés de l’espace de travail, puis sélectionnez Supprimer.Display the workspace properties, and then select Delete.

Étapes suivantesNext steps

Dans ce tutoriel sur les pipelines Machine Learning, vous avez effectué les tâches suivantes :In this machine learning pipelines tutorial, you did the following tasks:

  • Création d’un pipeline avec des dépendances d’environnement à exécuter sur une ressource de calcul GPU distanteBuilt a pipeline with environment dependencies to run on a remote GPU compute resource.
  • Création d’un script de scoring pour exécuter des prédictions par lots à l’aide d’un modèle Tensorflow préentraînéCreated a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • Publication d’un pipeline à exécuter à partir d’un point de terminaison RESTPublished a pipeline and enabled it to be run from a REST endpoint.

Pour obtenir des exemples supplémentaires de création de pipelines à l’aide du kit SDK Machine Learning, consultez le dépôt de notebooks.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.