Implementar modelos para puntuación en puntos de conexión por lotes

Artículo
09/03/2024

SE APLICA A:Extensión ML de la CLI de Azure v2 (actual)SDK de Python azure-ai-ml v2 (actual)

Los puntos de conexión de Batch proporcionan una manera cómoda de implementar modelos que ejecutan la inferencia en grandes volúmenes de datos. Estos puntos de conexión simplifican el proceso de hospedaje de los modelos para la puntuación por lotes, de modo que el enfoque se centre en el aprendizaje automático, en lugar de en la infraestructura.

Utilice puntos de conexión por lotes para la implementación de modelo cuando:

Tenga modelos costosos que requieran un tiempo más largo para ejecutar la inferencia.
Debe realizar la inferencia en grandes cantidades de datos que se distribuyen en varios archivos.
Si no tiene requisitos de latencia baja.
Si puede aprovechar la paralelización.

En este artículo, utilizará un punto de conexión por lotes para implementar un modelo de aprendizaje automático que resuelva el problema de reconocimiento de dígitos clásico de MNIST (Modified National Institute of Standards and Technology). A continuación, el modelo implementado realiza la inferencia por lotes en grandes cantidades de datos (en este caso, archivos de imagen). Para empezar, cree una implementación por lotes de un modelo que se creó mediante Torch. Esta implementación se convierte en la predeterminada en el punto de conexión. Más adelante, creará una segunda implementación de un modo que se creó con TensorFlow (Keras), probar la segunda implementación y, a continuación, establecerla como implementación predeterminada del punto de conexión.

Para seguir los ejemplos de código y los archivos necesarios para ejecutar los comandos de este artículo localmente, consulte la sección Clonar el repositorio de ejemplos. Los archivos y ejemplos de código se encuentran en el repositorio azureml-examples.

Requisitos previos

Antes de seguir los pasos descritos en este artículo, asegúrese de que tiene los siguientes requisitos previos:

Suscripción a Azure. Si no tiene una suscripción de Azure, cree una cuenta gratuita antes de empezar. Pruebe la versión gratuita o de pago de Azure Machine Learning.
Un área de trabajo de Azure Machine Learning. Si no tuvieras uno, sigue los pasos descritos en el artículo Cómo administrar áreas de trabajo para crear uno.
Para realizar las siguientes tareas, asegúrese de que tiene estos permisos en el área de trabajo:
- Para crear o administrar puntos de conexión e implementaciones por lotes: Utilice el rol de propietario, el rol de colaborador o un rol personalizado que permita Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Para crear implementaciones de ARM en el grupo de recursos del área de trabajo: Utilice el rol propietario, el rol de colaborador o un rol personalizado, lo que permite Microsoft.Resources/deployments/write en el grupo de recursos donde se implementa el área de trabajo.
Es necesario instalar el siguiente software para trabajar con Azure Machine Learning:
SE APLICA A: Extensión de ML de la CLI de Azure v2 (actual)

La CLI de Azure y la ml extensión para Azure Machine Learning.
```
az extension add -n ml
```
SE APLICA A: SDK de Python azure-ai-ml v2 (actual)

Instale el SDK de Azure Machine Learning para Python.
```
pip install azure-ai-ml
```
No hay más requisitos si tiene previsto usar Estudio de Azure Machine Learning.

Clone el repositorio de ejemplos

El ejemplo de este artículo se basa en ejemplos de código incluidos en el repositorio azureml-examples. Para ejecutar los comandos de forma local sin tener que copiar/pegar YAML y otros archivos, primero clona el repositorio y luego cambia los directorios a la carpeta:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli/endpoints/batch/deploy-models/mnist-classifier

!git clone https://github.com/Azure/azureml-examples --depth 1
!cd azureml-examples/sdk/python/endpoints/batch/deploy-models/mnist-classifier

Para seguir este ejemplo en un cuaderno de Jupyter Notebook, en el repositorio clonado, abra el cuaderno: mnist-batch.ipynb.

Preparación del sistema

Conexión con su área de trabajo

Primero, conéctese al área de trabajo de Azure Machine Learning donde realizará su trabajo.

Si aún no ha establecido los valores predeterminados de la CLI de Azure, guarde la configuración predeterminada. Para evitar pasar los valores de la suscripción, el área de trabajo, el grupo de recursos y la ubicación varias veces, ejecute este código:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

El área de trabajo es el recurso de nivel superior para Azure Machine Learning, que proporciona un lugar centralizado para trabajar con todos los artefactos que crea al usar Azure Machine Learning. En esta sección, se conectará al área de trabajo en la que realizará tareas de implementación.

Importe las bibliotecas necesarias:

from azure.ai.ml import MLClient, Input, load_component
from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
from azure.ai.ml.dsl import pipeline
from azure.identity import DefaultAzureCredential

Nota

Las clases ModelBatchDeployment y PipelineComponentBatchDeployment se introdujeron en la versión 1.7.0 del SDK.

Configure los detalles del área de trabajo y obtenga un manipulador para el área de trabajo:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Creación del proceso

Los puntos de conexión de Batch se ejecutan en clústeres de proceso y admiten clústeres de proceso de Azure Machine Learning (AmlCompute) y clústeres de Kubernetes. Los clústeres son un recurso compartido, por lo tanto, un clúster puede hospedar una o varias implementaciones por lotes (junto con otras cargas de trabajo, si lo desea).

Cree un proceso denominado batch-cluster, como se muestra en el código siguiente. Puede ajustar según sea necesario y hacer referencia al proceso mediante azureml:<your-compute-name>.

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="CPU cluster compute",
        min_instances=0,
        max_instances=2,
    )
    ml_client.compute.begin_create_or_update(compute_cluster).result()

Nota:

No se le cobra por el proceso en este momento, ya que el clúster permanece en 0 nodos hasta que se invoca un punto de conexión por lotes y se envía un trabajo de puntuación por lotes. Para obtener más información sobre los costos de proceso, consulte Administración y optimización del costo de AmlCompute.

Creación de un punto de conexión por lotes

Un punto de conexión por lotes es un punto de conexión HTTPS al que los clientes pueden llamar para desencadenar un trabajo de puntuación por lotes. Un trabajo de puntuación por lotes es un trabajo que puntúa varias entradas. Una implementación por lotes es un conjunto de recursos de proceso que hospedan el modelo que realiza la puntuación por lotes real (o la inferencia por lotes). Un punto de conexión por lotes puede tener varias implementaciones. Para obtener más información sobre los puntos de conexión por lotes, consulte ¿Qué son los puntos de conexión por lotes?.

Sugerencia

Una de las implementaciones por lotes actúa como la implementación predeterminada para el punto de conexión. Cuando se invoca el punto de conexión, la implementación predeterminada realiza la puntuación por lotes real. Para obtener más información sobre los puntos de conexión y las implementaciones por lotes, consulte puntos de conexión por lotes e implementación por lotes.

Nombre del punto de conexión. El nombre del punto de conexión de debe ser único dentro de una región de Azure, ya que el nombre se incluye en el URI del punto de conexión. Por ejemplo, solo puede haber un punto de conexión por lotes con el nombre mybatchendpoint en westus2.
Coloque el nombre del punto de conexión en una variable para que pueda hacer referencia fácilmente a él más adelante.
```
ENDPOINT_NAME="mnist-batch"
```
Coloque el nombre del punto de conexión en una variable para que pueda hacer referencia fácilmente a él más adelante.
```
endpoint_name = "mnist-batch"
```
Proporcione el nombre del punto de conexión más adelante, en el momento en que cree la implementación.

Configuración del punto de conexión por lotes

El siguiente archivo YAML define un punto de conexión por lotes. Puede utilizar este archivo con el comando de la CLI para creación de puntos de conexión por lotes.

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: mnist-batch
description: A batch endpoint for scoring images from the MNIST dataset.
tags:
  type: deep-learning

En la tabla siguiente se describen las propiedades clave del punto de conexión. Para el esquema de YAML de punto de conexión por lotes completo, consulte Esquema de YAML de punto de conexión por lotes de la CLI (v2).

Clave	Descripción
`name`	El nombre del punto de conexión por lotes. Es preciso que sea único en el nivel de región de Azure.
`description`	Descripción del punto de conexión por lotes. Esta propiedad es opcional.
`tags`	Etiquetas que se van a incluir en el punto de conexión. Esta propiedad es opcional.

endpoint = BatchEndpoint(
    name=endpoint_name,
    description="A batch endpoint for scoring images from the MNIST dataset.",
    tags={"type": "deep-learning"},
)

En la tabla siguiente se describen las propiedades clave del punto de conexión. Para obtener más información sobre la definición del punto de conexión por lotes, vea clase BatchEndpoint.

Clave	Descripción
`name`	El nombre del punto de conexión por lotes. Es preciso que sea único en el nivel de región de Azure.
`description`	Descripción del punto de conexión por lotes. Esta propiedad es opcional.
`tags`	Etiquetas que se van a incluir en el punto de conexión. Esta propiedad es opcional.

Creación del punto de conexión:
Ejecute el código siguiente para crear un punto de conexión por lotes.
```
az ml batch-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME
```
```
ml_client.begin_create_or_update(endpoint).result()
```
El punto de conexión se crea más adelante, en el momento en que se crea la implementación.

Creación de una implementación por lotes

Una implementación de modelo es un conjunto de recursos necesarios para hospedar el modelo que realiza la inferencia real. Para crear una implementación de modelos por lotes, necesita los siguientes elementos:

Un modelo registrado en el área de trabajo
El código para puntuar el modelo
Un entorno con las dependencias del modelo instaladas
El proceso creado previamente y la configuración de los recursos

Comience registrando el modelo para implementar, un modelo Torch para el popular problema de reconocimiento de dígitos (MNIST). Las implementaciones de Batch solo pueden implementar modelos registrados en el área de trabajo. Puede omitir este paso si el modelo que desea implementar ya está registrado.

Sugerencia

Los modelos están asociados a la implementación en lugar de estar asociados al punto de conexión. Esto significa que un único punto de conexión puede servir diferentes modelos (o versiones de modelo) en el mismo punto de conexión, siempre que los distintos modelos (o versiones de modelo) se implementen en distintas implementaciones.
```
MODEL_NAME='mnist-classifier-torch'
az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"
```
```
model_name = "mnist-classifier-torch"
model_local_path = "deployment-torch/model/"

model = ml_client.models.create_or_update(
    Model(
        name=model_name,
        path=model_local_path,
        type=AssetTypes.CUSTOM_MODEL,
        tags={"task": "classification", "framework": "torch"},
    )
)
```
1. Vaya a la pestaña Modelos en el menú lateral.
2. Seleccione Registrar>Desde archivos locales.
3. En el asistente, deje la opción Tipo de modelo como Tipo no especificado.
4. Seleccione Examinar>Examinar carpeta> Seleccione la carpeta deployment-torch/model>Siguiente.
5. Configure el nombre del modelo: mnist-classifier-torch. Puede dejar el resto de los campos tal como están.
6. Seleccione Registrar.

Ahora es el momento de crear un script de puntuación. Las implementaciones por lotes requieren un script de puntuación que indique cómo se debe ejecutar el modelo especificado y cómo se deben procesar los datos de entrada. Los puntos de conexión de Batch admiten scripts creados en Python. En este caso, se implementa un modelo que lee los archivos de imagen que representan dígitos y genera el dígito correspondiente. El script de puntuación tiene el siguiente aspecto:

Nota

En el caso de los modelos de MLflow, Azure Machine Learning genera automáticamente el script de puntuación, por lo que no es necesario proporcionar uno. Si el modelo es un modelo de MLflow, puede omitir este paso. Para obtener más información sobre cómo funcionan los puntos de conexión por lotes con modelos de MLflow, consulte el artículo Uso de modelos de MLflow en implementaciones por lotes.

Advertencia

Si va a implementar un modelo de aprendizaje automático automatizado (AutoML) en un punto de conexión por lotes, tenga en cuenta que el script de puntuación que AutoML proporciona solo funciona para los puntos de conexión en línea y no está diseñado para la ejecución por lotes. Para obtener información sobre cómo crear un script de puntuación para la implementación por lotes, consulte Creación de scripts de puntuación para implementaciones por lotes.

deployment-torch/code/batch_driver.py

import os
import pandas as pd
import torch
import torchvision
import glob
from os.path import basename
from mnist_classifier import MnistClassifier
from typing import List


def init():
    global model
    global device

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder
    model_path = os.environ["AZUREML_MODEL_DIR"]
    model_file = glob.glob(f"{model_path}/*/*.pt")[-1]

    model = MnistClassifier()
    model.load_state_dict(torch.load(model_file))
    model.eval()

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    with torch.no_grad():
        for image_path in mini_batch:
            image_data = torchvision.io.read_image(image_path).float()
            batch_data = image_data.expand(1, -1, -1, -1)
            input = batch_data.to(device)

            # perform inference
            predict_logits = model(input)

            # Compute probabilities, classes and labels
            predictions = torch.nn.Softmax(dim=-1)(predict_logits)
            predicted_prob, predicted_class = torch.max(predictions, axis=-1)

            results.append(
                {
                    "file": basename(image_path),
                    "class": predicted_class.numpy()[0],
                    "probability": predicted_prob.numpy()[0],
                }
            )

    return pd.DataFrame(results)

Cree un entorno en el que se ejecutará la implementación por lotes. El entorno debe incluir los paquetes azureml-core y azureml-dataset-runtime[fuse], que son necesarios para los puntos de conexión por lotes, además de cualquier dependencia que requiera el código para ejecutarse. En este caso, las dependencias se han capturado en un archivo conda.yaml:

deployment-torch/environment/conda.yaml
```
name: mnist-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip<22.0
  - pip:
    - torch==1.13.0
    - torchvision==0.14.0
    - pytorch-lightning
    - pandas
    - azureml-core
    - azureml-dataset-runtime[fuse]
```
Importante

Las implementaciones por lotes requieren los paquetes azureml-core y azureml-dataset-runtime[fuse], y deben incluirse en las dependencias del entorno.

Especifique el entorno de la siguiente manera:
La definición del entorno se incluirá en la propia definición de implementación como un entorno anónimo. Verá las líneas siguientes en la implementación:
```
environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
```
Obtenga una referencia al entorno:
```
env = Environment(
    name="batch-torch-py38",
    conda_file="deployment-torch/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
```
En Estudio de Azure Machine Learning, siga estos pasos:
1. Vaya a la pestaña Entornos del menú lateral.
2. Seleccione la pestaña Entornos personalizados>Crear.
3. Escriba el nombre del entorno, en este caso, torch-batch-env.
4. Para Seleccionar origen de entorno, seleccione Utilizar la imagen Docker existente con el archivo conda opcional.
5. En Ruta a la imagen del registro de contenedor, escriba mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
6. Seleccione Siguiente para ir a la sección "Personalizar".
7. Copie el contenido del archivo deployment-torch/environment/conda.yaml desde el repositorio de GitHub en el portal.
8. Seleccione Siguiente hasta llegar a la "página Revisar".
9. Seleccione Crear y espere hasta que el entorno esté listo para su uso.
Advertencia

Los entornos mantenidos no se admiten en las implementaciones por lotes. Debe especificar su propio entorno. Siempre puede usar la imagen base de un entorno mantenido como su entorno para simplificar el proceso.

Creación de una definición de implementación

deployment-torch/deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
name: mnist-torch-dpl
description: A deployment using Torch to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model:
  name: mnist-classifier-torch
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 30
  error_threshold: -1
  logging_level: info

En la tabla siguiente se describen las propiedades clave de la implementación por lotes. Para el esquema de YAML de implementación por lotes completo, consulte Esquema de YAML de implementación por lotes de la CLI (v2).

Clave	Descripción
`name`	Nombre de la implementación.
`endpoint_name`	El nombre del punto de conexión en el que se creará la implementación.
`model`	Modelo que se va a usar para la puntuación por lotes. En el ejemplo se define un modelo en línea mediante `path`. Esta definición permite que los archivos de modelo se carguen y registren automáticamente con un nombre y una versión generados automáticamente. Consulte el esquema del modelo para obtener más opciones. Como procedimiento recomendado para escenarios de producción, debe crear el modelo por separado y hacerle referencia aquí. Para hacer referencia a un modelo existente, use la sintaxis `azureml:<model-name>:<model-version>`.
`code_configuration.code`	El directorio local que contiene todo el código fuente Python para puntuar el modelo.
`code_configuration.scoring_script`	Archivo de Python en el directorio `code_configuration.code`. Este archivo debe tener una función `init()` y una función `run()`. Utilice la función `init()` para cualquier preparación costosa o común (por ejemplo, para cargar el modelo en memoria). `init()` se llamará solo una vez al principio del proceso. Use `run(mini_batch)` para puntuar cada entrada; el valor de `mini_batch` es una lista de rutas de acceso de archivo. La función `run()` debe devolver un dataframe de Pandas o una matriz. Cada elemento devuelto indica una ejecución correcta del elemento de entrada en `mini_batch`. Para obtener más información sobre cómo crear un script de puntuación, consulte Descripción del script de puntuación.
`environment`	El entorno en el que se va a puntuar el modelo. En el ejemplo se define un entorno en línea mediante `conda_file` y `image`. Las dependencias de `conda_file` se instalarán encima de `image`. El entorno se registrará de manera automática con un nombre y una versión generados automáticamente. Consulte el esquema de entorno para obtener más opciones. Como procedimiento recomendado para escenarios de producción, debe crear el entorno por separado y hacerle referencia aquí. Para hacer referencia a un entorno existente, use la sintaxis `azureml:<environment-name>:<environment-version>`.
`compute`	El proceso para ejecutar la puntuación por lotes. En el ejemplo se usa el `batch-cluster` creado al principio y se hace referencia a él mediante la sintaxis `azureml:<compute-name>`.
`resources.instance_count`	El número de instancias que se usarán para cada trabajo de puntuación por lotes.
`settings.max_concurrency_per_instance`	Número máximo de ejecuciones de `scoring_script` paralelas por instancia.
`settings.mini_batch_size`	Número de archivos que `scoring_script` puede procesar en una llamada a `run()`.
`settings.output_action`	Cómo se debe organizar la salida en el archivo de salida. `append_row` combinará todos los resultados de salida devueltos por `run()` en un único archivo denominado `output_file_name`. `summary_only` no combinará los resultados de salida y solo calculará `error_threshold`.
`settings.output_file_name`	El nombre del archivo de salida de puntuación por lotes para `append_row` `output_action`.
`settings.retry_settings.max_retries`	El número máximo de intentos erróneos de `scoring_script` `run()`.
`settings.retry_settings.timeout`	El tiempo de espera en segundos para `scoring_script` `run()` para puntuar un mini lote.
`settings.error_threshold`	El número de errores de puntuación de archivo de entrada que se deben omitir. Si el recuento de errores de toda la entrada supera este valor, el trabajo de puntuación por lotes se terminará. En el ejemplo se usa `-1`, que indica que se permite cualquier número de errores sin que se termine el trabajo de puntuación por lotes.
`settings.logging_level`	nivel de detalle del registro. Los valores en el aumento del nivel de detalle son: WARNING, INFO y DEBUG.
`settings.environment_variables`	Diccionario de pares nombre-valor de variable de entorno que se establecerán para cada trabajo de puntuación por lotes.

deployment = ModelBatchDeployment(
    name="mnist-torch-dpl",
    description="A deployment using Torch to solve the MNIST classification dataset.",
    endpoint_name=endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(
        code="deployment-torch/code/", scoring_script="batch_driver.py"
    ),
    environment=env,
    compute=compute_name,
    settings=ModelBatchDeploymentSettings(
        max_concurrency_per_instance=2,
        mini_batch_size=10,
        instance_count=2,
        output_action=BatchDeploymentOutputAction.APPEND_ROW,
        output_file_name="predictions.csv",
        retry_settings=BatchRetrySettings(max_retries=3, timeout=30),
        logging_level="info",
    ),
)

La clase BatchDeployment permite configurar las siguientes propiedades clave de una implementación por lotes:

Clave	Descripción
`name`	Nombre de la implementación.
`endpoint_name`	Nombre del punto de conexión en el que se creará la implementación.
`model`	Modelo que se usará para la implementación. Este valor puede ser una referencia a un modelo con versiones existente en el área de trabajo o una especificación de modelo en línea.
`environment`	El entorno que se usará para la implementación. Este valor puede ser una referencia a un entorno con versiones existente en el área de trabajo o una especificación de entorno en línea (opcional para modelos MLflow).
`code_configuration`	La configuración sobre cómo ejecutar la inferencia para el modelo (opcional para los modelos MLflow).
`code_configuration.code`	Ruta de acceso al directorio de código fuente para la puntuación del modelo.
`code_configuration.scoring_script`	Ruta de acceso relativa al archivo de puntuación en el directorio de código fuente.
`compute`	Nombre del destino de proceso en el que se van a ejecutar los trabajos de puntuación por lotes.
`instance_count`	Número de nodos que se usarán para cada trabajo de puntuación por lotes.
`settings`	Configuración de inferencia de implementación de modelo.
`settings.max_concurrency_per_instance`	Número máximo de ejecuciones de `scoring_script` paralelas por instancia.
`settings.mini_batch_size`	Número de archivos que `code_configuration.scoring_script` puede procesar en una llamada a `run` ().
`settings.retry_settings`	Vuelva a intentar la configuración para puntuar cada mini lote.
`settings.retry_settingsmax_retries`	El número máximo de reintentos para un minilote erróneo o con tiempo de espera (el valor predeterminado es 3).
`settings.retry_settingstimeout`	El tiempo de espera en segundos para puntuar un minilote (el valor predeterminado es 30).
`settings.output_action`	Cómo se debe organizar la salida en el archivo de salida. Los valores permitidos son: `append_row` o `summary_only`. El valor predeterminado es `append_row`.
`settings.logging_level`	Nivel de detalle del registro. Los valores permitidos son: `warning`, `info`, `debug`. El valor predeterminado es `info`.
`settings.environment_variables`	Diccionario de pares nombre-valor de variable de entorno que se establecerán para cada trabajo de puntuación por lotes.

En Studio, siga estos pasos:

Vaya a la pestaña Puntos de conexión del menú lateral.
Seleccione la pestaña Puntos de conexión por lotes>Crear.
Asigne un nombre al punto de conexión, en este caso, mnist-batch. Puede configurar el resto de los campos o dejarlos en blanco.
Seleccione Siguiente para ir a la sección "Modelo".
Seleccione el modelo mnist-classifier-torch.
Seleccione Siguiente para ir a la página "Implementación".
Asigne un nombre a la implementación.
En acción de Salida, asegúrese de que la fila Anexar está seleccionada.
En nombre de archivo de salida, asegúrese de que el archivo de salida de puntuación por lotes es el que necesita. El valor predeterminado es predictions.csv.
En tamaño de lote mini, ajuste el tamaño de los archivos que se incluirán en cada minilote. Este tamaño controlará la cantidad de datos que recibe el script de puntuación por lote.
En tiempo de espera de puntuación (segundos), asegúrese de que proporciona tiempo suficiente para que la implementación pueda puntuar un lote determinado de archivos. Si aumenta el número de archivos, normalmente también tiene que aumentar el valor de tiempo de espera. Es posible que los modelos más caros (como los basados en el aprendizaje profundo), requieran valores altos en este campo.
En simultaneidad máxima por instancia, configure el número de ejecutores que desea tener para cada instancia de proceso que obtenga en la implementación. Un número mayor aquí garantiza un mayor grado de paralelización, pero también aumenta la presión de memoria en la instancia de proceso. Ajuste este valor junto con Tamaño del minilote.
Una vez hecho esto, seleccione Siguiente para ir a la página "Código y entorno".
En "Seleccionar un script de puntuación para la inferencia", busque y seleccione el archivo de script de puntuación deployment-torch/code/batch_driver.py.
En la sección "Seleccionar entorno", seleccione el entorno que creó anteriormente torch-batch-env.
Seleccione Siguiente para ir a la página "Proceso".
Seleccione el clúster de proceso que creó en un paso anterior.

Advertencia

El clúster de Azure Kubernetes se admite en las implementaciones por lotes, pero solo cuando se crea mediante la CLI de Azure Machine Learning o el SDK de Python.
En recuento de instancias, escriba el número de instancias de proceso que desea para la implementación. En este caso, utilice 2.
Seleccione Siguiente.

Creación de la implementación:
Ejecute el código siguiente para crear una implementación por lotes en el punto de conexión por lotes y establézcala como la implementación predeterminada.
```
az ml batch-deployment create --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default
```
Sugerencia

El parámetro --set-default establece la implementación recién creada como la implementación predeterminada del punto de conexión. Es una manera cómoda de crear una nueva implementación predeterminada del punto de conexión, especialmente para la primera creación de la implementación. Como procedimiento recomendado para escenarios de producción, es posible que desee crear una nueva implementación sin establecerla como predeterminada. Compruebe que la implementación funciona según lo previsto y, a continuación, actualice la implementación predeterminada más adelante. Para obtener más información sobre cómo implementar este proceso, consulte la sección Implementación de un nuevo modelo.
Mediante MLClient creado anteriormente, cree la implementación en el área de trabajo. Este comando inicia la creación de la implementación y devuelve una respuesta de confirmación mientras continúa la creación de la implementación.
```
ml_client.begin_create_or_update(deployment).result()
```
Una vez completada la implementación, establezca la nueva implementación como la implementación predeterminada en el punto de conexión:
```
endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
En el asistente, seleccione Crear para iniciar el proceso de implementación.
Compruebe los detalles de la implementación y el punto de conexión por lotes.
Use show para comprobar los detalles del punto de conexión y la implementación. Para comprobar una implementación por lotes, ejecute el código siguiente:
```
DEPLOYMENT_NAME="mnist-torch-dpl"
az ml batch-deployment show --name $DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME
```
Para comprobar una implementación por lotes, ejecute el código siguiente:
```
ml_client.batch_deployments.get(name=deployment.name, endpoint_name=endpoint.name)
```
Después de crear el punto de conexión por lotes, se abre la página de detalles del punto de conexión. También puede encontrar esta página siguiendo estos pasos:
1. Vaya a la pestaña Puntos de conexión del menú lateral.
2. Seleccione la pestaña Puntos de conexión por lotes.
3. Seleccione el punto de conexión por lotes que desea ver.
4. La página Detalles del punto de conexión muestra los detalles del punto de conexión junto con todas las implementaciones disponibles en el punto de conexión.

Ejecución de puntos de conexión por lotes y resultados de acceso

La invocación de un punto de conexión por lotes desencadena un trabajo de puntuación por lotes. El trabajo name se devuelve de la respuesta de invocación y se puede usar para realizar un seguimiento del progreso de la puntuación por lotes. Al ejecutar modelos para la puntuación en puntos de conexión por lotes, debe especificar la ruta de acceso a los datos de entrada para que los puntos de conexión puedan encontrar los datos que desea puntuar. En el ejemplo siguiente se muestra cómo iniciar un nuevo trabajo sobre una muestra de datos del conjunto de datos MNIST almacenado en una cuenta de Azure Storage.

Puede ejecutar e invocar un punto de conexión por lotes mediante la CLI de Azure, el SDK de Azure Machine Learning o los puntos de conexión REST. Para obtener más información sobre estas opciones, consulte Creación de trabajos y datos de entrada para puntos de conexión por lotes.

Nota:

¿Cómo funciona la paralelización?

Las implementaciones por lotes distribuyen el trabajo en el nivel de archivo, lo que significa que una carpeta que contenga 100 archivos con minilotes de 10 archivos generará 10 lotes de 10 archivos cada uno. Observe que esto sucede independientemente del tamaño de los archivos implicados. Si los archivos son demasiado grandes para procesarse en minilotes grandes, se recomienda dividir los archivos en archivos más pequeños para lograr un mayor nivel de paralelismo o reducir el número de archivos por minilote. Actualmente, las implementaciones por lotes no pueden tener en cuenta los sesgos en la distribución de tamaño de un archivo.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Sugerencia

¿Cuál es la diferencia entre el parámetro inputs y input al invocar un punto de conexión?

En general, puede usar un parámetro de diccionario inputs = {} con el método invoke para proporcionar un número arbitrario de entradas necesarias a un punto de conexión por lotes que contenga una implementación de modelo o una implementación de canalización.

Para una implementación de modelo, puede usar el parámetro input como una forma más corta de especificar la ubicación de los datos de entrada para la implementación. Este enfoque funciona porque una implementación de modelo siempre toma una entrada de datos.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
)

Vaya a la pestaña Puntos de conexión del menú lateral.
Seleccione la pestaña Puntos de conexión por lotes.
Seleccione el punto de conexión por lotes que acaba de crear.
Seleccione Crear trabajo.
En implementación, seleccione la implementación que se va a ejecutar.
Seleccione Siguiente para ir a la página "Seleccionar origen de datos".
En "Tipo de origen de datos", seleccione almacén de datos.
En "Almacén de datos", seleccione workspaceblobstore en el menú desplegable.
En "Ruta de acceso", escriba la dirección URL completa https://azuremlexampledata.blob.core.windows.net/data/mnist/sample.

Sugerencia

Esta ruta de acceso solo funciona porque la ruta de acceso especificada tiene habilitado el acceso público. En general, debe registrar el origen de datos como un Almacén de datos. Consulte Acceso a datos desde trabajos de puntos de conexión por lotes para obtener más información.
Seleccione Siguiente.
Seleccione Crear para iniciar el trabajo.

Los puntos de conexión por lotes admiten la lectura de archivos o carpetas que se encuentran en diferentes ubicaciones. Para obtener más información sobre los tipos admitidos y cómo especificarlos, consulte Acceso a datos desde trabajos de puntos de conexión por lotes.

Supervisión del progreso de la ejecución del trabajo por lotes

Los trabajos de puntuación por lotes suelen tardar algún tiempo en procesar todo el conjunto de entradas.

El código siguiente comprueba el estado del trabajo y genera un vínculo a Estudio de Azure Machine Learning para obtener más detalles.

az ml job show -n $JOB_NAME --web

El código siguiente comprueba el estado del trabajo y genera un vínculo a Estudio de Azure Machine Learning para obtener más detalles.

ml_client.jobs.get(job.name)

Comprobación de los resultados de la puntuación por lotes

Las salidas del trabajo se almacenan en el almacenamiento en la nube, ya sea en el almacenamiento de blobs predeterminado del área de trabajo o en el almacenamiento especificado. Para obtener información sobre cómo cambiar los valores predeterminados, consulte Configuración de la ubicación de salida. Los pasos siguientes le permiten ver los resultados de puntuación en el Explorador de Azure Storage cuando se completa el trabajo:

Ejecute el código siguiente para abrir el trabajo de puntuación por lotes en Estudio de Azure Machine Learning. El vínculo del estudio de trabajo se incluye también en la respuesta de invoke, como el valor de interactionEndpoints.Studio.endpoint.
```
az ml job show -n $JOB_NAME --web
```
En el grafo del trabajo, seleccione el paso batchscoring.
Seleccione la pestaña Resultados y registros y, después, Show data outputs (Mostrar salidas de datos).
En Data outputs (Salidas de datos), seleccione el icono para abrir el Explorador de Storage.

Los resultados de puntuación del Explorador de Storage son similares a la página de ejemplo siguiente:

Configuración de la ubicación de salida

De manera predeterminada, los resultados de puntuación por lotes se almacenan en el almacén de blobs predeterminado del área de trabajo dentro de una carpeta denominada por nombre de trabajo (un GUID generado por el sistema). Puede configurar dónde almacenar las salidas de puntuación al invocar el punto de conexión por lotes.

Use output-path para configurar cualquier carpeta en un almacén de datos registrado de Azure Machine Learning. La sintaxis de --output-path es la misma que --input cuando se especifica una carpeta, es decir, azureml://datastores/<datastore-name>/paths/<path-on-datastore>/. Use --set output_file_name=<your-file-name> para configurar un nuevo nombre de archivo de salida.

OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
OUTPUT_PATH="azureml://datastores/workspaceblobstore/paths/$ENDPOINT_NAME"

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Use params_override para configurar cualquier carpeta en un almacén de datos registrado de Azure Machine Learning. Solo se admiten almacenes de datos registrados como rutas de acceso de salida. En este ejemplo se usa el almacén de datos predeterminado:

batch_ds = ml_client.datastores.get_default()

Una vez que haya identificado el almacén de datos que desea usar, configure la salida de la siguiente manera:

filename = f"predictions-{random.randint(0,99999)}.csv"

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
    params_override=[
        {"output_dataset.datastore_id": f"azureml:{batch_ds.id}"},
        {"output_dataset.path": f"/{endpoint_name}/"},
        {"output_file_name": filename},
    ],
)

Advertencia

Debe usar una ubicación de salida única. Si el archivo de salida existe, el trabajo de puntuación por lotes generará errores.

Importante

A diferencia de las entradas, las salidas solo se pueden almacenar en almacenes de datos de Azure Machine Learning que se ejecutan en cuentas de almacenamiento de blobs.

Sobrescribir la configuración de implementación para cada trabajo

Al invocar un punto de conexión por lotes, se puede sobrescribir algunas opciones de configuración para aprovechar mejor los recursos de proceso y mejorar el rendimiento. Las siguientes opciones se pueden configurar por trabajo:

Recuento de instancias: Utilice esta configuración para sobrescribir la cantidad de instancias que se solicitarán desde el clúster de proceso. Por ejemplo, para un mayor volumen de entradas de datos, puede que quiera usar más instancias para acelerar la puntuación por lotes de un extremo a otro.
Tamaño de minilote: Utilice esta configuración para sobrescribir la cantidad de archivos que se incluirán en cada mini lote. El número de minilotes se decide mediante el número total de recuentos de archivos de entrada y el tamaño de minilote. Un tamaño de minilote más pequeño genera más minilotes. Los mini lotes se pueden ejecutar en paralelo, pero puede haber una sobrecarga adicional de programación e invocación.
Otras opciones de configuración, como número máximo de reintentos, tiempo de espera y umbral de error se pueden sobrescribir. Esta configuración puede afectar al tiempo de la puntuación por lotes de un extremo a otro para distintas cargas de trabajo.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --mini-batch-size 20 --instance-count 5 --query name -o tsv)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/"
    ),
    params_override=[{"mini_batch_size": "20"}, {"compute.instance_count": "5"}],
)

Adición de implementaciones a un punto de conexión

Una vez que tenga un punto de conexión por lotes con una implementación, puede seguir refinando el modelo y agregar nuevas implementaciones. Los puntos de conexión por lotes seguirán sirviendo a la implementación predeterminada mientras desarrolla e implementa nuevos modelos en el mismo punto de conexión. Las implementaciones no afectan entre sí.

En este ejemplo, agregará una segunda implementación que usa un modelo compilado con Keras y TensorFlow para resolver el mismo problema de MNIST.

Adición de una segunda implementación

Cree un entorno en el que se ejecutará la implementación por lotes. Incluya en el entorno cualquier dependencia que el código requiera para ejecutarse. También debe agregar la biblioteca azureml-core, ya que es necesario para que las implementaciones por lotes funcionen. La siguiente definición de entorno tiene las bibliotecas necesarias para ejecutar un modelo con TensorFlow.
La definición de entorno se incluye en la propia definición de implementación como un entorno anónimo.
```
environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
```
Obtenga una referencia al entorno:
```
env = Environment(
    name="batch-tensorflow-py38",
    conda_file="deployment-keras/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
```
1. Vaya a la pestaña Entornos del menú lateral.
2. Seleccione la pestaña Entornos personalizados>Crear.
3. Escriba el nombre del entorno, en este caso, keras-batch-env.
4. Para Seleccionar origen de entorno, seleccione Utilizar la imagen Docker existente con el archivo conda opcional.
5. En Ruta a la imagen del registro de contenedor, escriba mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
6. Seleccione Siguiente para ir a la sección "Personalizar".
7. Copie el contenido del archivo deployment-keras/environment/conda.yaml desde el repositorio de GitHub en el portal.
8. Seleccione Siguiente hasta llegar a la "página Revisar".
9. Seleccione Crear y espere hasta que el entorno esté listo para su uso.
El archivo conda utilizado tiene el aspecto siguiente:

deployment-keras/environment/conda.yaml
```
name: tensorflow-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - pandas
    - tensorflow
    - pillow
    - azureml-core
    - azureml-dataset-runtime[fuse]
```

Cree un script de puntuación para el modelo:

deployment-keras/code/batch_driver.py

import os
import numpy as np
import pandas as pd
import tensorflow as tf
from typing import List
from os.path import basename
from PIL import Image
from tensorflow.keras.models import load_model


def init():
    global model

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")

    # load the model
    model = load_model(model_path)


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    for image_path in mini_batch:
        data = Image.open(image_path)
        data = np.array(data)
        data_batch = tf.expand_dims(data, axis=0)

        # perform inference
        pred = model.predict(data_batch)

        # Compute probabilities, classes and labels
        pred_prob = tf.math.reduce_max(tf.math.softmax(pred, axis=-1)).numpy()
        pred_class = tf.math.argmax(pred, axis=-1).numpy()

        results.append(
            {
                "file": basename(image_path),
                "class": pred_class[0],
                "probability": pred_prob,
            }
        )

    return pd.DataFrame(results)

Creación de una definición de implementación
deployment-keras/deployment.yml
```
$schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
name: mnist-keras-dpl
description: A deployment using Keras with TensorFlow to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model: 
  name: mnist-classifier-keras
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
```
```
deployment_keras = ModelBatchDeployment(
    name="mnist-keras-dpl",
    description="A deployment using Keras to solve the MNIST classification dataset.",
    endpoint_name=endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(
        code="deployment-keras/code/", scoring_script="batch_driver.py"
    ),
    environment=env,
    compute=compute_name,
    settings=ModelBatchDeploymentSettings(
        instance_count=2,
        max_concurrency_per_instance=2,
        mini_batch_size=10,
        output_action=BatchDeploymentOutputAction.APPEND_ROW,
        output_file_name="predictions.csv",
        retry_settings=BatchRetrySettings(max_retries=3, timeout=30),
        logging_level="info",
    ),
)
```
1. Vaya a la pestaña Puntos de conexión del menú lateral.
2. Seleccione la pestaña Puntos de conexión por lotes.
3. Seleccione el punto de conexión por lotes existente en el que quiere agregar la implementación.
4. Seleccione Agregar una implementación.
5. Seleccione Siguiente para ir a la página "Modelo".
6. En la lista de modelos, seleccione el modelo mnist y seleccione Siguiente.
7. En la página de configuración de la implementación, asigne un nombre a la implementación.
8. Deshacer la selección de la opción: Haga que esta nueva implementación sea la predeterminada para los trabajos por lotes.
9. En acción de Salida, asegúrese de que la fila Anexar está seleccionada.
10. En nombre de archivo de salida, asegúrese de que el archivo de salida de puntuación por lotes es el que necesita. El valor predeterminado es predictions.csv.
11. En tamaño de minilote, ajuste el tamaño de los archivos que se incluirán en cada minilote. Esto controlará la cantidad de datos que recibe el script de puntuación para cada lote.
12. En tiempo de espera de puntuación (segundos), asegúrese de que proporciona tiempo suficiente para que la implementación pueda puntuar un lote determinado de archivos. Si aumenta el número de archivos, normalmente también tiene que aumentar el valor de tiempo de espera. Es posible que los modelos más caros (como los basados en el aprendizaje profundo), requieran valores altos en este campo.
13. En simultaneidad máxima por instancia, configure el número de ejecutores que desea tener para cada instancia de proceso que obtenga en la implementación. Un número mayor aquí garantiza un mayor grado de paralelización, pero también aumenta la presión de memoria en la instancia de proceso. Ajuste este valor junto con Tamaño del minilote.
14. Seleccione Siguiente para ir a la pestaña "Código y entorno".
15. Para Seleccionar un script de puntuación para la inferencia, busque seleccionar el archivo de script de puntuación deployment-keras/code/batch_driver.py.
16. En Seleccionar entorno, seleccione el entorno que creó en un paso anterior.
17. Seleccione Siguiente.
18. En la página Proceso, seleccione el clúster de proceso que creó en un paso anterior.
19. En recuento de instancias, escriba el número de instancias de proceso que desea para la implementación. En este caso, utilice 2.
20. Seleccione Siguiente.
Creación de la implementación:
Ejecute el código siguiente para crear una implementación por lotes en el punto de conexión por lotes y establézcala como la implementación predeterminada.
```
az ml batch-deployment create --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME
```
Sugerencia

En este caso, falta el parámetro --set-default. Como procedimiento recomendado para escenarios de producción, cree una nueva implementación sin establecerla como predeterminada. El siguiente paso es comprobarla y actualizar la implementación predeterminada más adelante.
Mediante MLClient creado anteriormente, cree la implementación en el área de trabajo. Este comando inicia la creación de la implementación y devuelve una respuesta de confirmación mientras continúa la creación de la implementación.
```
ml_client.begin_create_or_update(deployment_keras).result()
```
En el asistente, seleccione Crear para iniciar el proceso de implementación.

Prueba de una implementación por lotes no predeterminada

Para probar la nueva implementación no predeterminada, debe conocer el nombre de la implementación que desea ejecutar.

DEPLOYMENT_NAME="mnist-keras-dpl"
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --deployment-name $DEPLOYMENT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Observe que --deployment-name se usa para especificar la implementación que se va a ejecutar. Este parámetro permite invoke una implementación no predeterminada sin actualizar la implementación predeterminada del punto de conexión por lotes.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment_keras.name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
)

Observe que deployment_name se usa para especificar la implementación que se va a ejecutar. Este parámetro permite invoke una implementación no predeterminada sin actualizar la implementación predeterminada del punto de conexión por lotes.

Actualización de la implementación por lotes predeterminada

Aunque puede invocar una implementación específica dentro de un punto de conexión, normalmente querrá invocar el propio punto de conexión y dejar que el punto de conexión decida qué implementación usar, la implementación predeterminada. Puede cambiar la implementación predeterminada (y, en consecuencia, cambiar el modelo que atiende la implementación) sin cambiar el contrato con el usuario invocando el punto de conexión. Use el código siguiente para actualizar la implementación predeterminada:

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment_keras.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

Eliminación del punto de conexión y la implementación por lotes

Si no va a usar la implementación de lotes anterior, elimínela ejecutando el siguiente código. --yes se usa para confirmar la eliminación.

az ml batch-deployment delete --name mnist-torch-dpl --endpoint-name $ENDPOINT_NAME --yes

Ejecute el siguiente código para eliminar el punto de conexión por lotes y todas sus implementaciones subyacentes. Los trabajos de puntuación por lotes no se eliminarán.

az ml batch-endpoint delete --name $ENDPOINT_NAME --yes

Si no va a usar la implementación de lotes anterior, elimínela ejecutando el siguiente código.

ml_client.batch_deployments.begin_delete(
    endpoint_name=endpoint_name, name=deployment.name
).result()

Ejecute el siguiente código para eliminar el punto de conexión por lotes y todas sus implementaciones subyacentes. Los trabajos de puntuación por lotes no se eliminarán.

ml_client.batch_endpoints.begin_delete(name=endpoint_name)

Compartir a través de

Implementar modelos para puntuación en puntos de conexión por lotes

Requisitos previos

Clone el repositorio de ejemplos

Preparación del sistema

Conexión con su área de trabajo

Creación del proceso

Creación de un punto de conexión por lotes

Creación de una implementación por lotes

Ejecución de puntos de conexión por lotes y resultados de acceso

Supervisión del progreso de la ejecución del trabajo por lotes

Comprobación de los resultados de la puntuación por lotes

Configuración de la ubicación de salida

Sobrescribir la configuración de implementación para cada trabajo

Adición de implementaciones a un punto de conexión

Adición de una segunda implementación

Prueba de una implementación por lotes no predeterminada

Actualización de la implementación por lotes predeterminada

Eliminación del punto de conexión y la implementación por lotes

Comentarios

Recursos adicionales

Compartir a través de

Implementar modelos para puntuación en puntos de conexión por lotes

Requisitos previos

Clone el repositorio de ejemplos

Preparación del sistema

Conexión con su área de trabajo

Creación del proceso

Creación de un punto de conexión por lotes

Creación de una implementación por lotes

Ejecución de puntos de conexión por lotes y resultados de acceso

Supervisión del progreso de la ejecución del trabajo por lotes

Comprobación de los resultados de la puntuación por lotes

Configuración de la ubicación de salida

Sobrescribir la configuración de implementación para cada trabajo

Adición de implementaciones a un punto de conexión

Adición de una segunda implementación

Prueba de una implementación por lotes no predeterminada

Actualización de la implementación por lotes predeterminada

Eliminación del punto de conexión y la implementación por lotes

Contenido relacionado

Comentarios

Recursos adicionales