Compartir a través de

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

  • Artículo

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:

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

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>

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

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.

  1. 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"

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

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

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

  1. 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"

  2. 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)

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

    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.

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

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

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

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)

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

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:

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

  2. En el grafo del trabajo, seleccione el paso batchscoring.

  3. Seleccione la pestaña Resultados y registros y, después, Show data outputs (Mostrar salidas de datos).

  4. En Data outputs (Salidas de datos), seleccione el icono para abrir el Explorador de Storage.

    Captura de pantalla de Estudio en la que se muestra la vista de la ubicación de las salidas de datos.

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

    Captura de pantalla de la salida de puntuación.

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)

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)

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

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

    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]

  2. 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)

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

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

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.

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

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

Contenido relacionado