Tutorial: Compilación de una canalización de Azure Machine Learning para la puntuación por lotesTutorial: Build an Azure Machine Learning pipeline for batch scoring

SE APLICA A: síBasic Edition síEnterprise Edition                    (Actualización a Enterprise Edition)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

En este tutorial avanzado, aprenderá a crear una canalización en Azure Machine Learning para ejecutar un trabajo de puntuación por lotes.In this advanced tutorial, you learn how to build a pipeline in Azure Machine Learning to run a batch scoring job. Las canalizaciones de Machine Learning optimizan el flujo de trabajo con velocidad, portabilidad y reutilización, con el fin de que pueda centrarse en el aprendizaje automático, en lugar de en la infraestructura y la automatización.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on machine learning instead of infrastructure and automation. Después de compilar y publicar una canalización, configurará un punto de conexión REST para desencadenar la canalización desde cualquier biblioteca HTTP en cualquier plataforma.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.

En el ejemplo se usa un modelo de red neuronal convolucional Inception-V3 entrenado previamente implementado en Tensorflow para clasificar las imágenes sin etiquetar.The example uses a pretrained Inception-V3 convolutional neural network model implemented in Tensorflow to classify unlabeled images. Más información sobre las canalizaciones de aprendizaje automático.Learn more about machine learning pipelines.

En este tutorial, va a completar las siguientes tareas:In this tutorial, you complete the following tasks:

  • Configuración del área de trabajoConfigure workspace
  • Descargar y almacenar datos de muestraDownload and store sample data
  • Crear objetos de un conjunto de datos para capturar y generar datosCreate dataset objects to fetch and output data
  • Descargar, preparar y registrar el modelo en el área de trabajoDownload, prepare, and register the model in your workspace
  • Aprovisionar destinos de proceso y crear un script de puntuaciónProvision compute targets and create a scoring script
  • Usar la clase ParallelRunStep para la puntuación de lotes asincrónicosUse the ParallelRunStep class for async batch scoring
  • Compilar, ejecutar y publicar una canalizaciónBuild, run, and publish a pipeline
  • Habilitar un punto de conexión REST para la canalizaciónEnable a REST endpoint for the pipeline

Si no tiene una suscripción de Azure, cree una cuenta gratuita antes de empezar.If you don't have an Azure subscription, create a free account before you begin. Pruebe hoy mismo la versión gratuita o de pago de Azure Machine Learning.Try the free or paid version of Azure Machine Learning today.

Requisitos previosPrerequisites

  • Complete la parte 1 del tutorial de instalación si aún no tiene un área de trabajo de Azure Machine Learning o una máquina virtual de cuadernos.If you don't already have an Azure Machine Learning workspace or notebook virtual machine, complete Part 1 of the setup tutorial.
  • Una vez terminado el tutorial de instalación, use el mismo servidor de cuadernos para abrir el cuaderno 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 desea ejecutar el tutorial de instalación en su propio entorno local puede acceder al tutorial en GitHub.If you want to run the setup tutorial in your own local environment, you can access the tutorial on GitHub. Ejecute pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests para obtener los paquetes requeridos.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-pipeline-steps pandas requests to get the required packages.

Configuración del área de trabajo y creación de un almacén de datosConfigure workspace and create a datastore

Cree un objeto de área de trabajo a partir del área de trabajo de Azure Machine Learning existente.Create a workspace object from the existing Azure Machine Learning workspace.

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

Importante

Este fragmento de código espera que la configuración del área de trabajo se guarde en el directorio actual o en su elemento primario.This code snippet expects the workspace configuration to be saved in the current directory or its parent. Para más información sobre cómo crear un área de trabajo, consulte Creación y administración de áreas de trabajo de Azure Machine Learning.For more information on creating a workspace, see Create and manage Azure Machine Learning workspaces. Para más información sobre cómo guardar la configuración en un archivo, consulte Creación de un archivo de configuración de área de trabajo.For more information on saving the configuration to file, see Create a workspace configuration file.

Creación de un almacén de datos para las imágenes de ejemploCreate a datastore for sample images

En la cuenta pipelinedata, obtenga el ejemplo de datos públicos de evaluación de ImageNet del contenedor de blobs público sampledata.On the pipelinedata account, get the ImageNet evaluation public data sample from the sampledata public blob container. Una llamada a register_azure_blob_container() hace que los datos estén disponibles en el área de trabajo con el nombre images_datastore.Call register_azure_blob_container() to make the data available to the workspace under the name images_datastore. A continuación, establezca el almacén de datos predeterminado del área de trabajo como almacén de datos de salidaThen, set the workspace default datastore as the output datastore. y úselo para puntuar las salidas de la canalización.Use the output datastore to score output in the pipeline.

Para obtener más información sobre el acceso a los datos, consulte cómo acceder a los datos.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()

Crear objetos de conjunto de datosCreate dataset objects

Al compilar canalizaciones, se usan objetos Dataset para leer datos de los almacenes de datos del área de trabajo, y objetos PipelineData para transferir los datos intermedios entre los pasos de la canalización.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.

Importante

En el ejemplo de puntuación por lotes de este tutorial solo se usa un paso de canalización.The batch scoring example in this tutorial uses only one pipeline step. En los casos de uso con varios pasos, el flujo típico incluirá los siguientes:In use cases that have multiple steps, the typical flow will include these steps:

  1. Use objetos Dataset como entradas para capturar datos sin procesar, realizar algunas transformaciones y generar un objeto PipelineData de salida.Use Dataset objects as inputs to fetch raw data, perform some transformation, and then output a PipelineData object.

  2. Use el PipelineData objeto de salida del paso anterior como objeto de entrada.Use the PipelineData output object in the preceding step as an input object. Repítalo en pasos posteriores.Repeat it for subsequent steps.

En este escenario se crean objetos Dataset correspondientes a los directorios del almacén de datos para las imágenes de entrada y las etiquetas de clasificación (valores de la prueba de la 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). También se crea un objeto PipelineData para los datos de salida de puntuación por lotes.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")

A continuación, registre los conjuntos de datos en el área de trabajo.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")

Descarga y registro del modeloDownload and register the model

Descargue el modelo Tensorflow previamente entrenado para usarlo en la puntuación por lotes de una canalización.Download the pretrained Tensorflow model to use it for batch scoring in a pipeline. En primer lugar, cree un directorio local donde almacenar el modeloFirst, create a local directory where you store the model. y, luego, descárguelo y extráigalo.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")

A continuación registrará el modelo en el área de trabajo para poder recuperarlo fácilmente en el proceso de canalización.Next, register the model to your workspace, so you can easily retrieve the model in the pipeline process. En la función estática register(), el parámetro model_name es la clave que se usa para buscar el modelo en todo el 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)

Creación y asociación del destino de proceso remotoCreate and attach the remote compute target

Las canalizaciones de aprendizaje automático no se pueden ejecutar en un entorno local, por lo que debe ejecutarlas en recursos en la nube o destinos de proceso remotos.Machine learning pipelines can't be run locally, so you run them on cloud resources or remote compute targets. Un destino de proceso remoto es un entorno de proceso virtual reutilizable en el que se ejecutan los experimentos y los flujos de trabajo de aprendizaje automático.A remote compute target is a reusable virtual compute environment where you run experiments and machine learning workflows.

Ejecute el código siguiente para crear un destino AmlCompute habilitado para GPU y asócielo al área de trabajo.Run the following code to create a GPU-enabled AmlCompute target, and then attach it to your workspace. Consulte el artículo conceptual para más información sobre los destinos de proceso.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)

Escritura de un script de puntuaciónWrite a scoring script

Para realizar la puntuación, cree un script de puntuación por lotes llamado batch_scoring.py y escríbalo en el directorio actual.To do the scoring, create a batch scoring script called batch_scoring.py, and then write it to the current directory. El script toma imágenes de entrada, aplica el modelo de clasificación y envía las predicciones a un archivo de resultados.The script takes input images, applies the classification model, and then outputs the predictions to a results file.

El script batch_scoring.py toma los siguientes parámetros, que se pasan desde el paso ParallelRunStep que se crea más adelante:The batch_scoring.py script takes the following parameters, which get passed from the ParallelRunStep you create later:

  • --model_name: nombre del modelo que se usa.--model_name: The name of the model being used.
  • --labels_dir: ubicación del archivo labels.txt.--labels_dir: The location of the labels.txt file.

La infraestructura de la canalización usa la clase ArgumentParser para pasar los parámetros a los pasos de canalización.The pipeline infrastructure uses the ArgumentParser class to pass parameters into pipeline steps. Por ejemplo, en el código siguiente, al primer argumento --model_name se le da el identificador de propiedad model_name.For example, in the following code, the first argument --model_name is given the property identifier model_name. En la función init() se utiliza Model.get_model_path(args.model_name) para acceder a esta propiedad.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

Sugerencia

La canalización de este tutorial solo tiene un paso y escribe la salida en un archivo.The pipeline in this tutorial has only one step, and it writes the output to a file. En el caso de las canalizaciones de varios pasos, también se usa ArgumentParser para definir un directorio en el que escribir los datos de salida para la entrada en pasos posteriores.For multi-step pipelines, you also use ArgumentParser to define a directory to write output data for input to subsequent steps. Consulte el cuadernoArgumentParser para ver un ejemplo de cómo pasar datos entre varios pasos de la canalización mediante el modelo de diseño .For an example of passing data between multiple pipeline steps by using the ArgumentParser design pattern, see the notebook.

Creación de la canalizaciónBuild the pipeline

Antes de ejecutar la canalización, cree un objeto que defina el entorno de Python y cree las dependencias que necesita el 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 dependencia principal requerida es Tensorflow, pero también se instalan azureml-core y azureml-dataprep[fuse], que se necesitan en ParallelRunStep.The main dependency required is Tensorflow, but you also install azureml-core and azureml-dataprep[fuse] which are required by ParallelRunStep. Además, especifique la compatibilidad con Docker y 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

Creación de la configuración para encapsular el scriptCreate the configuration to wrap the script

Cree el paso de canalización mediante el script, la configuración del entorno y los parámetros.Create the pipeline step using the script, environment configuration, and parameters. Especifique el destino de proceso que ya adjuntó a su área de trabajo.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
)

Creación del paso de canalizaciónCreate the pipeline step

Un paso de canalización es un objeto que encapsula todo lo que necesita para ejecutar una canalización, por ejemplo:A pipeline step is an object that encapsulates everything you need to run a pipeline, including:

  • Configuración del entorno y las dependenciasEnvironment and dependency settings
  • El recurso de proceso en el que se ejecutará la canalizaciónThe compute resource to run the pipeline on
  • Los datos de entrada y salida, y cualquier parámetro personalizadoInput and output data, and any custom parameters
  • Referencia a un script o a una lógica del SDK que se ejecutará durante el pasoReference to a script or SDK logic to run during the step

Varias clases heredan de la clase primaria PipelineStep.Multiple classes inherit from the parent class PipelineStep. Puede elegir clases para usar marcos o pilas concretos para compilar un paso.You can choose classes to use specific frameworks or stacks to build a step. En este ejemplo, se usa la clase ParallelRunStep para definir la lógica del paso con un script de Python personalizado.In this example, you use the ParallelRunStep class to define your step logic by using a custom Python script. Si un argumento del script es una entrada al paso o una salida del paso, se debe definir el argumento tanto en la matriz arguments, como en el parámetro input o output, respectivamente.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.

En escenarios con más de un paso, las referencias a un objeto de la matriz outputs estarán disponibles como entrada en un paso posterior de la canalización.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
)

Para ver una lista de todas las clases que se pueden usar para los diferentes tipos de pasos, consulte el paquete de pasos.For a list of all the classes you can use for different step types, see the steps package.

Enviar la canalizaciónSubmit the pipeline

Ahora ejecute la canalización.Now, run the pipeline. En primer lugar, cree un objeto Pipeline con la referencia al área de trabajo y el paso de canalización que creó.First, create a Pipeline object by using your workspace reference and the pipeline step you created. El parámetro steps es una matriz de pasos.The steps parameter is an array of steps. En este caso, la puntuación por lotes consta de un solo paso.In this case, there's only one step for batch scoring. Para compilar canalizaciones con varios pasos, colóquelos en orden en esta matriz.To build pipelines that have multiple steps, place the steps in order in this array.

Luego, use la función Experiment.submit() para enviar la canalización para su ejecución.Next, use the Experiment.submit() function to submit the pipeline for execution. La función wait_for_completion genera registros durante el proceso de compilación de la canalizaciónThe wait_for_completion function outputs logs during the pipeline build process. que puede usar para ver el progreso.You can use the logs to see current progress.

Importante

La primera ejecución de canalización tarda aproximadamente 15 minutos.The first pipeline run takes roughly 15 minutes. Se deben descargar todas las dependencias, se crea una imagen de Docker y se aprovisiona y se crea el entorno de Python.All dependencies must be downloaded, a Docker image is created, and the Python environment is provisioned and created. La repetición de la ejecución de la canalización tarda mucho menos, ya que esos recursos se reutilizan en lugar de crearse.Running the pipeline again takes significantly less time because those resources are reused instead of created. Sin embargo, el tiempo de ejecución total de la canalización depende de la carga de trabajo de los scripts y de los procesos que se ejecutan en cada paso de la canalización.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)

Descarga y revisión de la salidaDownload and review output

Ejecute el siguiente código para descargar el archivo de salida creado a partir del script batch_scoring.pyRun the following code to download the output file that's created from the batch_scoring.py script. y, luego, explore los resultados de la puntuación.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)

Publicación y ejecución desde un punto de conexión RESTPublish and run from a REST endpoint

Ejecute el código siguiente para publicar la canalización en el área de trabajo.Run the following code to publish the pipeline to your workspace. En el área de trabajo de Azure Machine Learning Studio puede ver los metadatos de la canalización, incluidos el historial de ejecución y las duraciones.In your workspace in Azure Machine Learning studio, you can see metadata for the pipeline, including run history and durations. También puede ejecutar la canalización manualmente desde Studio.You can also run the pipeline manually from the studio.

La publicación de la canalización permite a un punto de conexión REST volver a ejecutar la canalización desde cualquier biblioteca HTTP en cualquier plataforma.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

Para ejecutar la canalización desde el punto de conexión REST, necesita un encabezado de autenticación de tipo portador de OAuth2.To run the pipeline from the REST endpoint, you need an OAuth2 Bearer-type authentication header. En el ejemplo siguiente se usa la autenticación interactiva, con fines ilustrativos; en la mayoría de los escenarios de producción que requieren autenticación automatizada o desatendida, use la autenticación de la entidad de servicio tal y como se describe en este artículo.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.

La autenticación de la entidad de servicio implica la creación de un Registro de aplicación en Azure Active Directory.Service principal authentication involves creating an App Registration in Azure Active Directory. Primero genere un secreto de cliente y, a continuación, conceda a la entidad de servicio el acceso de rol al área de trabajo de aprendizaje automático.First, you generate a client secret, and then you grant your service principal role access to your machine learning workspace. Use la clase ServicePrincipalAuthentication para administrar el flujo de autenticación.Use the ServicePrincipalAuthentication class to manage your authentication flow.

Tanto InteractiveLoginAuthentication como ServicePrincipalAuthentication heredan de AbstractAuthentication.Both InteractiveLoginAuthentication and ServicePrincipalAuthentication inherit from AbstractAuthentication. En ambos caso, use la función get_authentication_header() de la misma manera para capturar el encabezado: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()

Obtenga la dirección URL de REST de la propiedad endpoint del objeto de canalización publicado.Get the REST URL from the endpoint property of the published pipeline object. También puede encontrar la dirección URL de REST en el área de trabajo de Azure Machine Learning Studio.You can also find the REST URL in your workspace in Azure Machine Learning studio.

Compile una solicitud HTTP POST para el punto de conexión.Build an HTTP POST request to the endpoint. Especifique el encabezado de autenticación en la solicitud.Specify your authentication header in the request. Agregue un objeto de carga JSON con el nombre del experimento.Add a JSON payload object that has the experiment name.

Realice la solicitud para desencadenar la ejecución.Make the request to trigger the run. Incluya código para acceder a la clave Id desde el diccionario de respuestas para obtener el valor del identificador de ejecución.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"]

Use el identificador de ejecución para supervisar el estado de la nueva ejecución.Use the run ID to monitor the status of the new run. La nueva ejecución tardará otros 10-15 minutosThe new run takes another 10-15 min to finish.

y su aspecto será similar al de la canalización que se ejecutó anteriormente en el tutorial.The new run will look similar to the pipeline you ran earlier in the tutorial. Puede elegir no ver la salida completa.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()

Limpieza de recursosClean up resources

No complete esta sección si planea ejecutar otros tutoriales de Azure Machine Learning.Don't complete this section if you plan to run other Azure Machine Learning tutorials.

Detención de la instancia de procesoStop the compute instance

Si usó una instancia de proceso o VM de cuadernos, detenga la máquina virtual cuando no la esté usando a fin de reducir el costo.If you used a compute instance or Notebook VM, stop the VM when you are not using it to reduce cost.

  1. En el área de trabajo, seleccione Compute.In your workspace, select Compute.

  2. En la lista, seleccione la máquina virtual.From the list, select the VM.

  3. Seleccione Detener.Select Stop.

  4. Cuando esté listo para volver a usar el servidor, seleccione Iniciar.When you're ready to use the server again, select Start.

Eliminar todo el contenidoDelete everything

Si no va a usar los recursos creados, elimínelos para no incurrir en cargos:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. En Azure Portal, seleccione Grupos de recursos en el menú de la izquierda.In the Azure portal, in the left menu, select Resource groups.
  2. En la lista de grupos de recursos, seleccione el que ha creado.In the list of resource groups, select the resource group you created.
  3. Seleccione Eliminar grupo de recursos.Select Delete resource group.
  4. Escriba el nombre del grupo de recursos.Enter the resource group name. A continuación, seleccione Eliminar.Then, select Delete.

También puede mantener el grupo de recursos pero eliminar una sola área de trabajo.You can also keep the resource group but delete a single workspace. Muestre las propiedades del área de trabajo y seleccione Eliminar.Display the workspace properties, and then select Delete.

Pasos siguientesNext steps

En este tutorial de canalizaciones de aprendizaje automático, realizó las siguientes tareas:In this machine learning pipelines tutorial, you did the following tasks:

  • Compiló una canalización con dependencias del entorno para ejecutarse en un recurso de proceso de GPU remota.Built a pipeline with environment dependencies to run on a remote GPU compute resource.
  • Creó un script de puntuación para ejecutar predicciones por lotes con un modelo Tensorflow entrenado previamente.Created a scoring script to run batch predictions by using a pretrained Tensorflow model.
  • Publicó una canalización y la habilitó para ejecutarla desde un punto de conexión REST.Published a pipeline and enabled it to be run from a REST endpoint.

Para más ejemplos de cómo crear canalizaciones mediante el SDK de aprendizaje automático, consulte el repositorio de cuadernos.For more examples of how to build pipelines by using the machine learning SDK, see the notebook repository.