Ejecución de la inferencia por lotes en grandes cantidades de datos mediante Azure Machine LearningRun batch inference on large amounts of data by using Azure Machine Learning

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 esta guía paso a paso aprenderá a obtener inferencias en grandes cantidades de datos de forma asincrónica y en paralelo mediante el uso de Azure Machine Learning.In this how-to, you learn how to get inferences on large amounts of data asynchronously and in parallel by using Azure Machine Learning. La funcionalidad de inferencia por lotes que se describe aquí se encuentra en versión preliminar pública.The batch inference capability described here is in public preview. Se trata de un método de alto rendimiento y alta capacidad de proceso para generar inferencias y datos para el procesamiento.It's a high-performance and high-throughput way to generate inferences and processing data. Proporciona funcionalidades asincrónicas listas para su uso.It provides asynchronous capabilities out of the box.

Con la inferencia por lotes es sencillo escalar inferencias sin conexión a grandes clústeres de máquinas en terabytes de datos de producción, lo que aumenta la productividad y optimiza el costo.With batch inference, it's straightforward to scale offline inferences to large clusters of machines on terabytes of production data resulting in improved productivity and optimized cost.

En esta guía paso a paso aprenderá a realizar las tareas siguientes:In this how-to, you learn the following tasks:

  • Crear un recurso de proceso remoto.Create a remote compute resource.
  • Escribir un script de inferencia personalizado.Write a custom inference script.
  • Crear una canalización de Machine Learning para registrar un modelo de clasificación de imágenes previamente entrenado basado en el conjunto de datos de MNIST.Create a machine learning pipeline to register a pre-trained image classification model based on the MNIST dataset.
  • Usar el modelo para ejecutar la inferencia por lotes en las imágenes de ejemplo disponibles en la cuenta de Azure Blob Storage.Use the model to run batch inference on sample images available in your Azure Blob storage account.

Requisitos previosPrerequisites

  • 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 la versión gratuita o de pago de Azure Machine Learning.Try the free or paid version of the Azure Machine Learning.

  • Para un inicio rápido guiado, complete el tutorial de instalación si aún no tiene un área de trabajo de Azure Machine Learning o una máquina virtual de cuadernos.For a guided quickstart, complete the setup tutorial if you don't already have an Azure Machine Learning workspace or notebook virtual machine.

  • Para administrar el entorno y las dependencias propias, consulte la guía paso a paso sobre la configuración del entorno propio.To manage your own environment and dependencies, see the how-to guide on configuring your own environment. Ejecute pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-contrib-pipeline-steps en su entorno para descargar las dependencias necesarias.Run pip install azureml-sdk[notebooks] azureml-pipeline-core azureml-contrib-pipeline-steps in your environment to download the necessary dependencies.

Configurar los recursos de aprendizaje automáticoSet up machine learning resources

Las siguientes acciones configuran los recursos necesarios para ejecutar una canalización de inferencias por lotes:The following actions set up the resources that you need to run a batch inference pipeline:

  • Cree un almacén de datos que apunte a un contenedor de blobs que tenga imágenes para inferencia.Create a datastore that points to a blob container that has images to inference.
  • Configure referencias de datos como entradas y salidas para el paso de la canalización de inferencias por lotes.Set up data references as inputs and outputs for the batch inference pipeline step.
  • Configure un clúster de proceso para ejecutar el paso de inferencia por lotes.Set up a compute cluster to run the batch inference step.

Creación de un almacén de datos con imágenes de ejemploCreate a datastore with sample images

Obtenga el conjunto de evaluación de MNIST del contenedor de blobs público sampledata en una cuenta llamada pipelinedata.Get the MNIST evaluation set from the public blob container sampledata on an account named pipelinedata. Cree un almacén de datos con el nombre mnist_datastore que apunte a este contenedor.Create a datastore with the name mnist_datastore, which points to this container. En la siguiente llamada a register_azure_blob_container, si se establece la marca overwrite en True se sobrescribe cualquier almacén de datos que se haya creado anteriormente con ese nombre.In the following call to register_azure_blob_container, setting the overwrite flag to True overwrites any datastore that was created previously with that name.

Puede cambiar este paso para que apunte al contenedor de blobs si proporciona sus propios valores para datastore_name, container_name y account_name.You can change this step to point to your blob container by providing your own values for datastore_name, container_name, and account_name.

from azureml.core import Datastore
from azureml.core import Workspace

# Load workspace authorization details from config.json
ws = Workspace.from_config()

mnist_blob = Datastore.register_azure_blob_container(ws, 
                      datastore_name="mnist_datastore", 
                      container_name="sampledata", 
                      account_name="pipelinedata",
                      overwrite=True)

A continuación, especifique el almacén de datos predeterminado del área de trabajo como almacén de datos de salida.Next, specify the workspace default datastore as the output datastore. Lo usará para la salida de la inferencia.You'll use it for inference output.

Cuando cree su área de trabajo, Azure Files  y Blob Storage  se adjuntan al área de trabajo de forma predeterminada.When you create your workspace, Azure Files and Blob storage are attached to the workspace by default. Azure Files es el almacén de datos predeterminado para un área de trabajo, pero también puede usar Blob Storage como un almacén de datos.Azure Files is the default datastore for a workspace, but you can also use Blob storage as a datastore. Para obtener más información, consulte Opciones de almacenamiento de Azure.For more information, see Azure storage options.

def_data_store = ws.get_default_datastore()

Configuración de las entradas y salidas de datosConfigure data inputs and outputs

Ahora debe configurar las entradas y salidas de datos, entre las que se incluyen:Now you need to configure data inputs and outputs, including:

  • directorio que contiene las imágenes de entrada.The directory that contains the input images.
  • El directorio en el que se almacena el modelo previamente entrenado.The directory where the pre-trained model is stored.
  • El directorio que contiene las etiquetas.The directory that contains the labels.
  • El directorio de salida.The directory for output.

Dataset es una clase para explorar, transformar y administrar datos en Azure Machine Learning.Dataset is a class for exploring, transforming, and managing data in Azure Machine Learning. Esta clase tiene dos tipos: TabularDataset y FileDataset.This class has two types: TabularDataset and FileDataset. En este ejemplo usará FileDataset como entradas para el paso de canalización de inferencias por lotes.In this example, you'll use FileDataset as the inputs to the batch inference pipeline step.

Nota

Por ahora, la compatibilidad con FileDataset en la inferencia por lotes está restringida a Azure Blob Storage.FileDataset support in batch inference is restricted to Azure Blob storage for now.

También puede hacer referencia a otros conjuntos de datos del script de inferencia personalizado.You can also reference other datasets in your custom inference script. Por ejemplo, puede utilizarlo para acceder a las etiquetas del script para etiquetar las imágenes mediante Dataset.register y Dataset.get_by_name.For example, you can use it to access labels in your script for labeling images by using Dataset.register and Dataset.get_by_name.

Para más información sobre los conjuntos de datos de Azure Machine Learning, consulte Creación de conjuntos de datos y acceso a ellos (versión preliminar).For more information about Azure Machine Learning datasets, see Create and access datasets (preview).

Los objetos PipelineData se usan para transferir los datos intermedios entre los pasos de la canalización.PipelineData objects are used for transferring intermediate data between pipeline steps. En este ejemplo, se usa para las salidas de inferencia.In this example, you use it for inference outputs.

from azureml.core.dataset import Dataset

mnist_ds_name = 'mnist_sample_data'

path_on_datastore = mnist_blob.path('mnist/')
input_mnist_ds = Dataset.File.from_files(path=path_on_datastore, validate=False)
registered_mnist_ds = input_mnist_ds.register(ws, mnist_ds_name, create_new_version=True)
named_mnist_ds = registered_mnist_ds.as_named_input(mnist_ds_name)

output_dir = PipelineData(name="inferences", 
                          datastore=def_data_store, 
                          output_path_on_compute="mnist/results")

Configuración de un destino de procesoSet up a compute target

En Azure Machine Learning, el proceso (o destino de proceso) se refiere a las máquinas o clústeres que realizarán los pasos del cálculo en su canal de aprendizaje automático.In Azure Machine Learning, compute (or compute target) refers to the machines or clusters that perform the computational steps in your machine learning pipeline. Ejecute el código siguiente para crear un destino AmlCompute basado en CPU.Run the following code to create a CPU based AmlCompute target.

from azureml.core.compute import AmlCompute, ComputeTarget
from azureml.core.compute_target import ComputeTargetException

# choose a name for your cluster
compute_name = os.environ.get("AML_COMPUTE_CLUSTER_NAME", "cpu-cluster")
compute_min_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MIN_NODES", 0)
compute_max_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MAX_NODES", 4)

# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6
vm_size = os.environ.get("AML_COMPUTE_CLUSTER_SKU", "STANDARD_D2_V2")


if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('found compute target. just use it. ' + compute_name)
else:
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size = vm_size,
                                                                min_nodes = compute_min_nodes, 
                                                                max_nodes = compute_max_nodes)

    # create the cluster
    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)
    
    # can poll for a minimum number of nodes and for a specific timeout. 
    # if no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)
    
     # For a more detailed view of current AmlCompute status, use get_status()
    print(compute_target.get_status().serialize())

Preparar el modeloPrepare the model

Descargue el modelo de clasificación de imágenes previamente entrenado y extráigalo en el directorio models.Download the pre-trained image classification model, and then extract it to the models directory.

import os
import tarfile
import urllib.request

model_dir = 'models'
if not os.path.isdir(model_dir):
    os.mkdir(model_dir)

url="https://pipelinedata.blob.core.windows.net/mnist-model/mnist-tf.tar.gz"
response = urllib.request.urlretrieve(url, "model.tar.gz")
tar = tarfile.open("model.tar.gz", "r:gz")
tar.extractall(model_dir)

Después, registre el modelo con el área de trabajo para que esté disponible para el recurso de proceso remoto.Then register the model with your workspace so it's available to your remote compute resource.

from azureml.core.model import Model

# Register the downloaded model 
model = Model.register(model_path="models/",
                       model_name="mnist",
                       tags={'pretrained': "mnist"},
                       description="Mnist trained tensorflow model",
                       workspace=ws)

Escritura del script de inferenciaWrite your inference script

Advertencia

El código siguiente es solo un ejemplo que utiliza el cuaderno de ejemplo.The following code is only a sample that the sample notebook uses. Deberá crear su propio script para el escenario.You’ll need to create your own script for your scenario.

El script debe contener dos funciones:The script must contain two functions:

  • init(): utilice esta función para cualquier preparación costosa o común para la inferencia posterior.init(): Use this function for any costly or common preparation for later inference. Por ejemplo, para cargar el modelo en un objeto global.For example, use it to load the model into a global object.
  • run(mini_batch): la función se ejecutará para cada instancia de mini_batch.run(mini_batch): The function will run for each mini_batch instance.
    • mini_batch: la inferencia por lotes invocará el método run y pasará una trama de datos de Pandas o una lista como argumento al método.mini_batch: Batch inference will invoke run method and pass either a list or Pandas DataFrame as an argument to the method. Cada entrada de min_batch será una ruta de acceso si la entrada es FileDataset o una trama de datos de Pandas si es TabularDataset.Each entry in min_batch will be - a filepath if input is a FileDataset, a Pandas DataFrame if input is a TabularDataset.
    • response: el método run() debe devolver una trama de datos de Pandas o una matriz.response: run() method should return a Pandas DataFrame or an array. Para append_row output_action, estos elementos devueltos se anexan al archivo de salida común.For append_row output_action, these returned elements are appended into the common output file. Para summary_only, se omite el contenido de los elementos.For summary_only, the contents of the elements are ignored. Para todas las acciones de salida, cada elemento de salida devuelto indica una inferencia correcta del elemento de entrada en el minilote de entrada.For all output actions, each returned output element indicates one successful inference of input element in the input mini-batch. El usuario debe asegurarse de que se incluyen suficientes datos en el resultado de la inferencia para asignar la entrada a esta.User should make sure that enough data is included in inference result to map input to inference. La salida de la inferencia se escribirá en el archivo de salida y no se garantiza que esté en orden, por lo que el usuario debe usar alguna clave en la salida para asignarla a la entrada.Inference output will be written in output file and not guaranteed to be in order, user should use some key in the output to map it to input.
# Snippets from a sample script.
# Refer to the accompanying digit_identification.py
# (https://aka.ms/batch-inference-notebooks)
# for the implementation script.

import os
import numpy as np
import tensorflow as tf
from PIL import Image
from azureml.core import Model


def init():
    global g_tf_sess

    # Pull down the model from the workspace
    model_path = Model.get_model_path("mnist")

    # Construct a graph to execute
    tf.reset_default_graph()
    saver = tf.train.import_meta_graph(os.path.join(model_path, 'mnist-tf.model.meta'))
    g_tf_sess = tf.Session()
    saver.restore(g_tf_sess, os.path.join(model_path, 'mnist-tf.model'))


def run(mini_batch):
    print(f'run method start: {__file__}, run({mini_batch})')
    resultList = []
    in_tensor = g_tf_sess.graph.get_tensor_by_name("network/X:0")
    output = g_tf_sess.graph.get_tensor_by_name("network/output/MatMul:0")

    for image in mini_batch:
        # Prepare each image
        data = Image.open(image)
        np_im = np.array(data).reshape((1, 784))
        # Perform inference
        inference_result = output.eval(feed_dict={in_tensor: np_im}, session=g_tf_sess)
        # Find the best probability, and add it to the result list
        best_result = np.argmax(inference_result)
        resultList.append("{}: {}".format(os.path.basename(image), best_result))

    return resultList

Compilación y ejecución de la canalización de inferencias por lotesBuild and run the batch inference pipeline

Ahora ya tiene todo lo que necesita para compilar la canalización.Now you have everything you need to build the pipeline.

Preparación del entorno de ejecuciónPrepare the run environment

Primero, especifique las dependencias para el script.First, specify the dependencies for your script. Usará este objeto más adelante cuando cree el paso de canalización.You use this object later when you create the pipeline step.

from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.runconfig import DEFAULT_GPU_IMAGE

batch_conda_deps = CondaDependencies.create(pip_packages=["tensorflow==1.13.1", "pillow"])

batch_env = Environment(name="batch_environment")
batch_env.python.conda_dependencies = batch_conda_deps
batch_env.docker.enabled = True
batch_env.docker.base_image = DEFAULT_GPU_IMAGE
batch_env.spark.precache_packages = False

Especificación de los parámetros para el paso de canalización de inferencias por lotesSpecify the parameters for your batch inference pipeline step

ParallelRunConfig es la configuración principal de la instancia de ParallelRunStep de inferencia por lotes recién introducida en la canalización de Azure Machine Learning.ParallelRunConfig is the major configuration for the newly introduced batch inference ParallelRunStep instance within the Azure Machine Learning pipeline. Se usa para encapsular el script y configurar los parámetros necesarios, incluidos los siguientes:You use it to wrap your script and configure necessary parameters, including all of the following:

  • entry_script: script de usuario como ruta de acceso de archivo local que se ejecutará en paralelo en varios nodos.entry_script: A user script as a local file path that will be run in parallel on multiple nodes. Si source_directly está presente, utilice una ruta de acceso relativa.If source_directly is present, use a relative path. De lo contrario, use cualquier ruta de acceso accesible desde la máquina.Otherwise, use any path that's accessible on the machine.
  • mini_batch_size: tamaño del minilote que se pasa a una sola llamada de run().mini_batch_size: The size of the mini-batch passed to a single run() call. (Opcional: el valor predeterminado es 1).(Optional; the default value is 1.)
    • En el caso de FileDataset, es el número de archivos con un valor mínimo de 1.For FileDataset, it's the number of files with a minimum value of 1. Puede combinar varios archivos en un solo minilote.You can combine multiple files into one mini-batch.
    • En el caso de TabularDataset, es el tamaño de los datos.For TabularDataset, it's the size of data. Los valores posibles son 1024, 1024KB, 10MB y 1GB.Example values are 1024, 1024KB, 10MB, and 1GB. 1MB es el valor recomendado.The recommended value is 1MB. Tenga en cuenta que el minilote de TabularDataset nunca cruzará los límites de los archivos.Note that the mini-batch from TabularDataset will never cross file boundaries. Por ejemplo, si tiene archivos. csv de varios tamaños, el menor es de 100 KB y el mayor es de 10 MB.For example, if you have .csv files with various sizes, the smallest file is 100 KB and the largest is 10 MB. Si establece mini_batch_size = 1MB, los archivos con un tamaño menor que 1 MB se tratarán como un solo minilote.If you set mini_batch_size = 1MB, then files with a size smaller than 1 MB will be treated as one mini-batch. Los archivos de tamaño mayor que 1 MB se dividirán en varios minilotes.Files with a size larger than 1 MB will be split into multiple mini-batches.
  • error_threshold: número de errores de registro para TabularDataset y errores de archivo para FileDataset que se deben omitir durante el procesamiento.error_threshold: The number of record failures for TabularDataset and file failures for FileDataset that should be ignored during processing. Si el recuento de errores de la entrada supera este valor, el trabajo se detiene.If the error count for the entire input goes above this value, the job will be stopped. El umbral de error es para toda la entrada y no para los minilotes individuales que se envían al método run().The error threshold is for the entire input and not for individual mini-batches sent to the run() method. El intervalo es [-1, int.max].The range is [-1, int.max]. La parte -1 indica que se omitirán todos los errores durante el procesamiento.The -1 part indicates ignoring all failures during processing.
  • output_action: uno de los valores siguientes indica cómo se organizará la salida:output_action: One of the following values indicates how the output will be organized:
    • summary_only: el script de usuario almacenará la salida.summary_only: The user script will store the output. ParallelRunStep usará la salida solo para el cálculo del umbral de error.ParallelRunStep will use the output only for the error threshold calculation.
    • append_row: en los archivos de entrada solo se creará un archivo en la carpeta de salida para anexar todas las salidas separadas por líneas.append_row: For all input files, only one file will be created in the output folder to append all outputs separated by line. El nombre de archivo será parallel_run_step.txt.The file name will be parallel_run_step.txt.
  • source_directory: rutas de acceso a las carpetas que contienen todos los archivos que se van a ejecutar en el destino de proceso (opcional).source_directory: Paths to folders that contain all files to execute on the compute target (optional).
  • compute_target: Solo se admite AmlCompute.compute_target: Only AmlCompute is supported.
  • node_count: número de nodos de proceso que se usarán para ejecutar el script de usuario.node_count: The number of compute nodes to be used for running the user script.
  • process_count_per_node: número de procesos por nodo.process_count_per_node: The number of processes per node.
  • environment: definición del entorno de Python.environment: The Python environment definition. Puede configurarla para que use un entorno de Python existente o para un entorno temporal para el experimento.You can configure it to use an existing Python environment or to set up a temporary environment for the experiment. La definición también es responsable de establecer las dependencias de la aplicación necesarias (opcional).The definition is also responsible for setting the required application dependencies (optional).
  • logging_level: nivel de detalle del registro.logging_level: Log verbosity. Los valores con nivel de detalle en aumento son: WARNING, INFO y DEBUG.Values in increasing verbosity are: WARNING, INFO, and DEBUG. El valor predeterminado es INFO (opcional).The default is INFO (optional).
  • run_invocation_timeout: tiempo de espera de invocación del método run() en segundos.run_invocation_timeout: The run() method invocation timeout in seconds. El valor predeterminado es 60.The default value is 60.
from azureml.contrib.pipeline.steps import ParallelRunConfig

parallel_run_config = ParallelRunConfig(
    source_directory=scripts_folder,
    entry_script="digit_identification.py",
    mini_batch_size="5",
    error_threshold=10,
    output_action="append_row",
    environment=batch_env,
    compute_target=compute_target,
    node_count=4)

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

Cree el paso de canalización mediante el script, la configuración del entorno y los parámetros.Create the pipeline step by using the script, environment configuration, and parameters. Especifique el destino de proceso que ya adjuntó a su área de trabajo como destino de ejecución del script.Specify the compute target that you already attached to your workspace as the target of execution for the script. Use ParallelRunStep para crear el paso de canalización de inferencias por lotes, que toma todos los parámetros siguientes:Use ParallelRunStep to create the batch inference pipeline step, which takes all the following parameters:

  • name: nombre del paso, con las siguientes restricciones de nomenclatura: unique, 3-32 caracteres y regex ^[a-z]([-a-z0-9]*[a-z0-9])?$.name: The name of the step, with the following naming restrictions: unique, 3-32 characters, and regex ^[a-z]([-a-z0-9]*[a-z0-9])?$.
  • models: cero o más nombres de modelo ya registrados en el registro de modelos de Azure Machine Learning.models: Zero or more model names already registered in the Azure Machine Learning model registry.
  • parallel_run_config: objeto ParallelRunConfig, tal y como se definió anteriormente.parallel_run_config: A ParallelRunConfig object, as defined earlier.
  • inputs: uno o más conjuntos de datos de Azure Machine Learning de tipo único.inputs: One or more single-typed Azure Machine Learning datasets.
  • output: objeto PipelineData que corresponde al directorio de salida.output: A PipelineData object that corresponds to the output directory.
  • arguments: lista de argumentos pasados al script de usuario (opcional).arguments: A list of arguments passed to the user script (optional).
  • allow_reuse: sirve para decidir si el paso debe volver a usar los resultados anteriores cuando se ejecuta con la misma configuración o entrada.allow_reuse: Whether the step should reuse previous results when run with the same settings/inputs. Si este parámetro es False, siempre se generará una nueva ejecución para este paso durante la ejecución de la canalización.If this parameter is False, a new run will always be generated for this step during pipeline execution. (Opcional: el valor predeterminado es True).(Optional; the default value is True.)
from azureml.contrib.pipeline.steps import ParallelRunStep

parallelrun_step = ParallelRunStep(
    name="batch-mnist",
    models=[model],
    parallel_run_config=parallel_run_config,
    inputs=[named_mnist_ds],
    output=output_dir,
    arguments=[],
    allow_reuse=True
)

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 that 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.

from azureml.pipeline.core import Pipeline
from azureml.core.experiment import Experiment

pipeline = Pipeline(workspace=ws, steps=[parallelrun_step])
pipeline_run = Experiment(ws, 'digit_identification').submit(pipeline)

Supervisión del trabajo de inferencias por lotesMonitor the batch inference job

Un trabajo de inferencias por lotes puede tardar mucho tiempo.A batch inference job can take a long time to finish. En este ejemplo se supervisa el progreso mediante un widget de Jupyter.This example monitors progress by using a Jupyter widget. También puede administrar el progreso del trabajo mediante:You can also manage the job's progress by using:

  • Azure Machine Learning Studio.Azure Machine Learning Studio.
  • La salida de la consola del objeto PipelineRun.Console output from the PipelineRun object.
from azureml.widgets import RunDetails
RunDetails(pipeline_run).show()

pipeline_run.wait_for_completion(show_output=True)

Pasos siguientesNext steps

Para ver cómo funciona esto de un extremo a otro, pruebe el cuaderno de inferencias por lotes.To see this process working end to end, try the batch inference notebook.

Para instrucciones sobre depuración y solución de problemas para las canalizaciones, consulte la guía paso a paso.For debugging and troubleshooting guidance for pipelines, see the how-to guide.

Aprenda a ejecutar cuadernos, para lo que debe seguir el artículo, Use Jupyter notebooks to explore this service (Uso de cuadernos de Jupyter para explorar este servicio).Learn how to run notebooks by following the article, Use Jupyter notebooks to explore this service.