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 usará una canalización de Azure Machine Learning para ejecutar un trabajo de puntuación por lotes.In this tutorial, you use a pipeline in Azure Machine Learning to run a batch scoring job. En este ejemplo se usa el modelo Tensorflow de red neuronal de circunvolución Inception-V3 para clasificar las imágenes sin etiquetar.The example uses the pretrained Inception-V3 convolutional neural network Tensorflow model to classify unlabeled images. 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.

Las canalizaciones de aprendizaje automático optimizan el flujo de trabajo con velocidad, portabilidad y reutilización para que pueda centrarse en sus conocimientos, el aprendizaje automático, en lugar de hacerlo en la infraestructura y la automatización.Machine learning pipelines optimize your workflow with speed, portability, and reuse, so you can focus on your expertise - machine learning - instead of on infrastructure and automation. 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:

  • Configurar el área de trabajo y descargar datos de ejemploConfigure workspace and download sample data
  • Crear objetos de datos para capturar y generar datosCreate data 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
  • 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 a 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/tutorial-pipeline-batch-scoring-classification.ipynb.When you finish the setup tutorial, use the same notebook server to open the tutorials/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.

  • Un área de trabajo es una clase que acepta la información de recursos y suscripciones de Azure.A workspace is a class that accepts your Azure subscription and resource information. También crea un recurso en la nube que puede usar para supervisar y realizar el seguimiento de las ejecuciones del modelo.The workspace also creates a cloud resource you can use to monitor and track your model runs.
  • Workspace.from_config() lee el archivo config.json y carga los detalles de autenticación en un objeto denominado ws.Workspace.from_config() reads the config.json file and then loads the authentication details into an object named ws. El objeto ws se usa en el código en todo el tutorial.The ws object is used in the code throughout this tutorial.
from azureml.core import Workspace
ws = Workspace.from_config()

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.

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

Creación de objetos de datosCreate data objects

Al compilar una canalización, un objeto DataReference lee los datos del almacén de datos del área de trabajo.When you build a pipeline, a DataReference object reads data from the workspace datastore. Un objeto PipelineData transfiere los datos intermedios entre los pasos de canalización.A PipelineData object transfers 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 DataReference como entradas para capturar datos sin procesar, realizar algunas transformaciones y generar un objeto PipelineData de salida.Use DataReference objects as inputs to fetch raw data, perform some transformation, and then output a PipelineData object.

  2. Use el objeto de salida PipelineData 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 DataReference 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 DataReference 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.data.data_reference import DataReference
from azureml.pipeline.core import PipelineData

input_images = DataReference(datastore=batchscore_blob, 
                             data_reference_name="input_images",
                             path_on_datastore="batchscoring/images",
                             mode="download"
                            )

label_dir = DataReference(datastore=batchscore_blob, 
                          data_reference_name="input_labels",
                          path_on_datastore="batchscoring/labels",
                          mode="download"                          
                         )

output_dir = PipelineData(name="scores", 
                          datastore=def_data_store, 
                          output_path_on_compute="batchscoring/results")

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 de canalización que se crea más adelante en este tutorial:The batch_scoring.py script takes the following parameters, which are passed from the pipeline step that you create later in this tutorial:

  • --model_name: nombre del modelo que se usa.--model_name: The name of the model being used.
  • --label_dir: directorio que contiene el archivo labels.txt.--label_dir: The directory that holds the labels.txt file.
  • --dataset_path: directorio que contiene las imágenes de entrada.--dataset_path: The directory that contains the input images.
  • --output_dir: directorio de salida del archivo results-label.txt después de que el script ejecute el modelo en los datos.--output_dir: The output directory for the results-label.txt file after the script runs the model on the data.
  • --batch_size: tamaño del lote que se usa para ejecutar el modelo.--batch_size: The batch size used in running the model.

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 main() se utiliza Model.get_model_path(args.model_name) para acceder a esta propiedad.In the main() 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.model import Model

slim = tf.contrib.slim

parser = argparse.ArgumentParser(description="Start a tensorflow model serving")
parser.add_argument('--model_name', dest="model_name", required=True)
parser.add_argument('--label_dir', dest="label_dir", required=True)
parser.add_argument('--dataset_path', dest="dataset_path", required=True)
parser.add_argument('--output_dir', dest="output_dir", required=True)
parser.add_argument('--batch_size', dest="batch_size", type=int, required=True)

args = parser.parse_args()

image_size = 299
num_channel = 3

# create output directory if it does not exist
os.makedirs(args.output_dir, exist_ok=True)


def get_class_label_dict(label_file):
    label = []
    proto_as_ascii_lines = tf.gfile.GFile(label_file).readlines()
    for l in proto_as_ascii_lines:
        label.append(l.rstrip())
    return label


class DataIterator:
    def __init__(self, data_dir):
        self.file_paths = []
        image_list = os.listdir(data_dir)
        self.file_paths = [data_dir + '/' + file_name.rstrip() for file_name in image_list]
        self.labels = [1 for file_name in self.file_paths]

    @property
    def size(self):
        return len(self.labels)

    def input_pipeline(self, batch_size):
        images_tensor = tf.convert_to_tensor(self.file_paths, dtype=tf.string)
        labels_tensor = tf.convert_to_tensor(self.labels, dtype=tf.int64)
        input_queue = tf.train.slice_input_producer([images_tensor, labels_tensor], shuffle=False)
        labels = input_queue[1]
        images_content = tf.read_file(input_queue[0])

        image_reader = tf.image.decode_jpeg(images_content, channels=num_channel, name="jpeg_reader")
        float_caster = tf.cast(image_reader, tf.float32)
        new_size = tf.constant([image_size, image_size], dtype=tf.int32)
        images = tf.image.resize_images(float_caster, new_size)
        images = tf.divide(tf.subtract(images, [0]), [255])

        image_batch, label_batch = tf.train.batch([images, labels], batch_size=batch_size, capacity=5 * batch_size)
        return image_batch


def main(_):
    label_file_name = os.path.join(args.label_dir, "labels.txt")
    label_dict = get_class_label_dict(label_file_name)
    classes_num = len(label_dict)
    test_feeder = DataIterator(data_dir=args.dataset_path)
    total_size = len(test_feeder.labels)
    count = 0

    # get model from model registry
    model_path = Model.get_model_path(args.model_name)

    with tf.Session() as sess:
        test_images = test_feeder.input_pipeline(batch_size=args.batch_size)
        with slim.arg_scope(inception_v3.inception_v3_arg_scope()):
            input_images = tf.placeholder(tf.float32, [args.batch_size, 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)

        sess.run(tf.global_variables_initializer())
        sess.run(tf.local_variables_initializer())
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        saver = tf.train.Saver()
        saver.restore(sess, model_path)
        out_filename = os.path.join(args.output_dir, "result-labels.txt")
        with open(out_filename, "w") as result_file:
            i = 0
            while count < total_size and not coord.should_stop():
                test_images_batch = sess.run(test_images)
                file_names_batch = test_feeder.file_paths[i * args.batch_size:
                                                          min(test_feeder.size, (i + 1) * args.batch_size)]
                results = sess.run(probabilities, feed_dict={input_images: test_images_batch})
                new_add = min(args.batch_size, total_size - count)
                count += new_add
                i += 1
                for j in range(new_add):
                    result_file.write(os.path.basename(file_names_batch[j]) + ": " + label_dict[results[j]] + "\n")
                result_file.flush()
            coord.request_stop()
            coord.join(threads)

        shutil.copy(out_filename, "./outputs/")

if __name__ == "__main__":
    tf.app.run()

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.

Compilación y ejecución de la canalizaciónBuild and run 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 instala azureml-defaults para los procesos en segundo plano desde el SDK.The main dependency required is Tensorflow, but you also install azureml-defaults from the SDK for background processes. Cree un objeto RunConfiguration con las dependencias.Create a RunConfiguration object by using the dependencies. Además, especifique la compatibilidad con Docker y Docker-GPU.Also, specify Docker and Docker-GPU support.

from azureml.core.runconfig import DEFAULT_GPU_IMAGE
from azureml.core.runconfig import CondaDependencies, RunConfiguration

cd = CondaDependencies.create(pip_packages=["tensorflow-gpu==1.13.1", "azureml-defaults"])

amlcompute_run_config = RunConfiguration(conda_dependencies=cd)
amlcompute_run_config.environment.docker.enabled = True
amlcompute_run_config.environment.docker.base_image = DEFAULT_GPU_IMAGE
amlcompute_run_config.environment.spark.precache_packages = False

Parametrización de la canalizaciónParameterize the pipeline

Defina un parámetro personalizado para que la canalización controle el tamaño del lote.Define a custom parameter for the pipeline to control the batch size. Una vez publicada la canalización y expuesta mediante un punto de conexión REST, también se exponen los parámetros configurados.After the pipeline is published and exposed via a REST endpoint, any configured parameters are also exposed. Puede especificar parámetros personalizados en la carga de JSON cuando vuelva a ejecutar la canalización mediante una solicitud HTTP.You can specify custom parameters in the JSON payload when you rerun the pipeline via an HTTP request.

Cree un objeto PipelineParameter para habilitar este comportamiento y definir un nombre y un valor predeterminado.Create a PipelineParameter object to enable this behavior and to define a name and default value.

from azureml.pipeline.core.graph import PipelineParameter
batch_size_param = PipelineParameter(name="param_batch_size", default_value=20)

Crear el 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 PythonScriptStep para definir la lógica del paso con un script de Python personalizado.In this example, you use the PythonScriptStep 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 PythonScriptStep

batch_score_step = PythonScriptStep(
    name="batch_scoring",
    script_name="batch_scoring.py",
    arguments=["--dataset_path", input_images, 
               "--model_name", "inception",
               "--label_dir", label_dir, 
               "--output_dir", output_dir, 
               "--batch_size", batch_size_param],
    compute_target=compute_target,
    inputs=[input_images, label_dir],
    outputs=[output_dir],
    runconfig=amlcompute_run_config
)

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.

Ejecución de la canalizaciónRun 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. También se especifica el parámetro personalizado param_batch_size.You also specify the custom parameter param_batch_size. 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_parameters={"param_batch_size": 20})
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

step_run = list(pipeline_run.get_children())[0]
step_run.download_file("./outputs/result-labels.txt")

df = pd.read_csv("result-labels.txt", delimiter=":", header=None)
df.columns = ["Filename", "Prediction"]
df.head(10)
Nombre de archivoFilename PredicciónPrediction
00 ILSVRC2012_val_00000102.JPEGILSVRC2012_val_00000102.JPEG Rhodesian RidgebackRhodesian Ridgeback
11 ILSVRC2012_val_00000103.JPEGILSVRC2012_val_00000103.JPEG tripodtripod
22 ILSVRC2012_val_00000104.JPEGILSVRC2012_val_00000104.JPEG typewriter keyboardtypewriter keyboard
33 ILSVRC2012_val_00000105.JPEGILSVRC2012_val_00000105.JPEG silky terriersilky terrier
44 ILSVRC2012_val_00000106.JPEGILSVRC2012_val_00000106.JPEG Windsor tieWindsor tie
55 ILSVRC2012_val_00000107.JPEGILSVRC2012_val_00000107.JPEG harvestmanharvestman
66 ILSVRC2012_val_00000108.JPEGILSVRC2012_val_00000108.JPEG violinviolin
77 ILSVRC2012_val_00000109.JPEGILSVRC2012_val_00000109.JPEG loudspeakerloudspeaker
88 ILSVRC2012_val_00000110.JPEGILSVRC2012_val_00000110.JPEG apronapron
99 ILSVRC2012_val_00000111.JPEGILSVRC2012_val_00000111.JPEG American lobsterAmerican lobster

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 cuaderno.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 notebook.

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 y el parámetro de tamaño de lote.Add a JSON payload object that has the experiment name and the batch size parameter. Como se indicó anteriormente en el tutorial, param_batch_size se pasa a su script batch_scoring.py, ya que se definió como objeto PipelineParameter en la configuración del paso.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.

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": {"param_batch_size": 50}})
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 máquina virtual de NotebookStop the Notebook VM

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.