Cómo hacer operativa una canalización de entrenamiento con puntos de conexión por lotes

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

En este artículo, aprenderás a poner en funcionamiento una canalización de entrenamiento en un punto de conexión por lotes. La canalización usa varios componentes (o pasos) que incluyen el entrenamiento del modelo, el preprocesamiento de datos y la evaluación del modelo.

Aprenderá lo siguiente:

• Crear y probar de una canalización de entrenamiento
• Implementar la canalización en un punto de conexión por lotes
• Modificar la canalización y creación de una nueva implementación en el mismo punto de conexión
• Prueba de la nueva implementación y su establecimiento como implementación predeterminada

Acerca de este ejemplo

En este ejemplo se implementa una canalización de entrenamiento que toma datos de entrenamiento de entrada (etiquetados) y genera un modelo predictivo, junto con los resultados de evaluación y las transformaciones aplicadas durante el preprocesamiento. La canalización utilizará datos tabulares del Conjunto de datos de enfermedades cardíacas de UCI para entrenar un modelo XGBoost. Usamos un componente de preprocesamiento de datos para preprocesar los datos antes de enviarlos al componente de capacitación para ajustar y evaluar el modelo.

Una visualización de la canalización es la siguiente:

El ejemplo de este artículo se basa en ejemplos de código incluidos en el repositorio azureml-examples. Para ejecutar los comandos localmente sin tener que copiar o pegar YAML y otros archivos, use los siguientes comandos para clonar el repositorio e ir a la carpeta del lenguaje de codificación:

CLI de Azure

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Python

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python

Los archivos de este ejemplo están en:

cd endpoints/batch/deploy-pipelines/training-with-components

Sigue estos pasos en los cuadernos de Jupyter Notebooks

Puedes seguir la versión SDK de Python de este ejemplo abriendo el cuaderno sdk-deploy-and-test.ipynb en el repositorio clonado.

Requisitos previos

• Suscripción a Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

• Un área de trabajo de Azure Machine Learning. Para crear un área de trabajo, vea Administración de áreas de trabajo de Azure Machine Learning.

• Los siguientes permisos en el área de trabajo de Azure Machine Learning:

  • Para crear o administrar puntos de conexión e implementaciones: utilice un rol de Propietario, Colaborador o personalizado al que se le hayan asignado los permisos Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
  • Para crear implementaciones de Azure Resource Manager en el grupo de recursos del área de trabajo: use un rol de Propietario, Colaborador o personalizado que tenga asignado el permiso Microsoft.Resources/deployments/write en el grupo de recursos donde se implementa el área de trabajo.

• La CLI de Azure Machine Learning o el SDK de Azure Machine Learning para Python:

  CLI de Azure

  Ejecute el siguiente comando para instalar la CLI de Azure y la extensión ml para Azure Machine Learning:

  az extension add -n ml
  

  Las implementaciones de componentes de canalización para puntos de conexión por lotes se introdujeron en la versión 2.7 de la extensión ml para la CLI de Azure. Use el comando az extension update --name ml para obtener la versión más reciente.

  Python

  Ejecute el siguiente comando para instalar el SDK de Azure Machine Learning para Python:

  pip install azure-ai-ml
  

  Las clases ModelBatchDeployment y PipelineComponentBatchDeployment se presentaron en la versión 1.7.0 del SDK. Use el comando pip install -U azure-ai-ml para obtener la versión más reciente.

---

Conexión con su área de trabajo

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

CLI de Azure

En el siguiente comando, escriba el id. de suscripción, el nombre del área de trabajo, el nombre de grupo de recursos y la ubicación:

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

Python

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

2. Configura los detalles del área de trabajo y obtén un manipulador para el área de trabajo:

   En el siguiente comando, escriba el id. de suscripción, el nombre del grupo de recursos y el nombre del área de trabajo:

   subscription_id = "<subscription>"
   resource_group = "<resource-group>"
   workspace = "<workspace>"
   
   ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
   

Crear el componente de canalización de entrenamiento

En esta sección, crearemos todos los recursos necesarios para nuestra canalización de entrenamiento. Comenzaremos creando un entorno que incluya las bibliotecas necesarias para entrenar el modelo. Después, crearemos un clúster de proceso en el que se ejecutará la implementación por lotes y, por último, registraremos los datos de entrada como un recurso de datos.

Creación del entorno

Los componentes de este ejemplo utilizarán un entorno con las bibliotecas XGBoost y scikit-learn. El archivo environment/conda.yml contiene la configuración de la implementación:

environment/conda.yml

channels:
- conda-forge
dependencies:
- python=3.8.5
- pip
- pip:
  - mlflow
  - azureml-mlflow
  - datasets
  - jobtools
  - cloudpickle==1.6.0
  - dask==2023.2.0
  - scikit-learn==1.1.2
  - xgboost==1.3.3
  - pandas==1.4
name: mlflow-env

Crear el entorno de la siguiente manera:

1. Definir el entorno:

   CLI de Azure

   environment/xgboost-sklearn-py38.yml

   $schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
   name: xgboost-sklearn-py38
   image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
   conda_file: conda.yml
   description: An environment for models built with XGBoost and Scikit-learn.
   

   Python

   environment = Environment(
       name="xgboost-sklearn-py38",
       description="An environment for models built with XGBoost and Scikit-learn.",
       image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
       conda_file="environment/conda.yml",
   )

2. Crear el entorno:

   CLI de Azure

   az ml environment create -f environment/xgboost-sklearn-py38.yml
   

   Python

   try:
       ml_client.environments.create_or_update(environment)
   except ResourceExistsError:
       pass

Creación de un clúster de proceso

Las implementaciones y puntos de conexión por lotes se ejecutan en clústeres de computación. Pueden ejecutarse en cualquier clúster de proceso de Azure Machine Learning que ya exista en el área de trabajo. Por lo tanto, varias implementaciones por lotes pueden compartir la misma infraestructura de proceso. En este ejemplo, trabajaremos en un clúster de proceso de Azure Machine Learning denominado batch-cluster. Verifiquemos que el cálculo exista en el área de trabajo o creémoslo de otra manera.

CLI de Azure

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

Python

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="Batch endpoints compute cluster",
        min_instances=0,
        max_instances=5,
    )
    ml_client.begin_create_or_update(compute_cluster).result()

Registrar los datos de entrenamiento como un activo de datos

Nuestros datos de entrenamiento están representados en archivos CSV. Para imitar una carga de trabajo más a nivel de producción, vamos a registrar los datos de entrenamiento en el archivo heart.csv como un activo de datos en el área de trabajo. Este recurso de datos se indicará posteriormente como entrada al punto de conexión.

CLI de Azure

az ml data create --name heart-classifier-train --type uri_folder --path data/train

Python

data_path = "data/train"
dataset_name = "heart-dataset-train"

heart_dataset_train = Data(
    path=data_path,
    type=AssetTypes.URI_FOLDER,
    description="A training dataset for heart classification",
    name=dataset_name,
)

Cree el recurso de datos:

ml_client.data.create_or_update(heart_dataset_train)

Vamos a obtener una referencia al nuevo recurso de datos:

heart_dataset_train = ml_client.data.get(name=dataset_name, label="latest")

Creación de la canalización

La canalización que queremos poner en funcionamiento toma una entrada, los datos de entrenamiento y genera tres salidas: el modelo entrenado, los resultados de evaluación y las transformaciones de datos aplicadas como preprocesamiento. La canalización consta de dos componentes:

• preprocess_job: este paso lee los datos de entrada y devuelve los datos preparados y las transformaciones aplicadas. El paso recibe tres entradas:
  • data: una carpeta que contiene los datos de entrada que se van a transformar y puntuar
  • transformations: (opcional) ruta de acceso a las transformaciones que se aplicarán, si están disponibles. Si no se proporciona la ruta de acceso, las transformaciones se aprenderán de los datos de entrada. Dado que la entrada transformations es opcional, el componente preprocess_job se puede utilizar durante el entrenamiento y la puntuación.
  • categorical_encoding: la estrategia de codificación para las características categóricas (ordinal o onehot).
• train_job: este paso entrenará un modelo XGBoost basado en los datos preparados y devolverá los resultados de evaluación y el modelo entrenado. El paso recibe tres entradas:
  • data: los datos preprocesados.
  • target_column: la columna que se quiere predecir.
  • eval_size: indica la proporción de los datos de entrada utilizados para la evaluación.

CLI de Azure

La configuración de la canalización se define en el archivo deployment-ordinal/pipeline.yml:

deployment-ordinal/pipeline.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
type: pipeline

name: uci-heart-train-pipeline
display_name: uci-heart-train
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

inputs:
  input_data:
    type: uri_folder

outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: ../components/prepare/prepare.yml
    inputs:
      data: ${{parent.inputs.input_data}}
      categorical_encoding: ordinal
    outputs:
      prepared_data:
      transformations_output: ${{parent.outputs.prepare_transformations}}
  
  train_job:
    type: command
    component: ../components/train_xgb/train_xgb.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      target_column: target
      register_best_model: false
      eval_size: 0.3
    outputs:
      model: 
        mode: upload
        type: mlflow_model
        path: ${{parent.outputs.model}}
      evaluation_results:
        mode: upload
        type: uri_folder
        path: ${{parent.outputs.evaluation_results}}

Nota

En el archivo pipeline.yml, falta la entrada transformations del preprocess_job; por lo tanto, el script aprenderá los parámetros de transformación de los datos de entrada.

Python

Las configuraciones de los componentes de canalización se encuentran en los archivos prepare.yml y train_xgb.yml . Cargar los componentes:

prepare_data = load_component(source="components/prepare/prepare.yml")
train_xgb = load_component(source="components/train_xgb/train_xgb.yml")

Construir la canalización:

@pipeline()
def uci_heart_classifier_trainer(input_data: Input(type=AssetTypes.URI_FOLDER)):
    prepared_data = prepare_data(data=input_data)
    trained_model = train_xgb(
        data=prepared_data.outputs.prepared_data,
        target_column="target",
        register_best_model=False,
        eval_size=0.3,
    )

    return {
        "model": trained_model.outputs.model,
        "evaluation_results": trained_model.outputs.evaluation_results,
        "transformations_output": prepared_data.outputs.transformations_output,
    }

Nota

En la canalización, falta la entrada transformations; por lo tanto, el script aprenderá los parámetros de los datos de entrada.

Una visualización de la canalización es la siguiente:

Prueba de la canalización

Probemos la canalización con algunos datos de ejemplo. Para ello, se creará un trabajo mediante la canalización y el clúster de proceso batch-cluster creados anteriormente.

CLI de Azure

El siguiente archivo pipeline-job.yml contiene la configuración del trabajo de canalización:

deployment-ordinal/pipeline-job.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

experiment_name: uci-heart-train-pipeline
display_name: uci-heart-train-job
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    mode: upload

Python

pipeline_job = uci_heart_classifier_trainer(
    Input(type="uri_folder", path=heart_dataset_train.id)
)

Ahora configuraremos algunos parámetros de ejecución para ejecutar la prueba:

pipeline_job.settings.default_datastore = "workspaceblobstore"
pipeline_job.settings.default_compute = "batch-cluster"

Crear el trabajo de prueba:

CLI de Azure

az ml job create -f deployment-ordinal/pipeline-job.yml --set inputs.input_data.path=azureml:heart-classifier-train@latest

Python

pipeline_job_run = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="uci-heart-train-pipeline"
)
pipeline_job_run

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

1. Proporcione un nombre para el punto de conexión. El nombre de un punto de conexión por lotes debe ser único en cada región, ya que el nombre se usa para construir el URI de invocación. Para garantizar la unicidad, anexa los caracteres finales al nombre especificado en el código siguiente.

   CLI de Azure

   ENDPOINT_NAME="uci-classifier-train"
   

   Python

   endpoint_name = "uci-classifier-train"

2. Configuración del punto de conexión:

   CLI de Azure

   El archivo endpoint.yml contiene la configuración del punto de conexión.

   endpoint.yml

   $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
   name: uci-classifier-train
   description: An endpoint to perform training of the Heart Disease Data Set prediction task.
   auth_mode: aad_token
   

   Python

   endpoint = BatchEndpoint(
       name=endpoint_name,
       description="An endpoint to perform training of the Heart Disease Data Set prediction task",
   )

3. Creación del punto de conexión:

   CLI de Azure

   az ml batch-endpoint create --name $ENDPOINT_NAME -f endpoint.yml
   

   Python

   ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

4. Consulta del URI del punto de conexión:

   CLI de Azure

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

   endpoint = ml_client.batch_endpoints.get(name=endpoint_name)
   print(endpoint)

Implementar el componente de canalización

Para implementar el componente de canalización, tendremos que crear una implementación por lotes. Una implementación es un conjunto de recursos necesarios para hospedar el recurso que realiza el trabajo real.

1. Configurar la implementación:

   CLI de Azure

   El archivo deployment-ordinal/deployment.yml contiene la configuración de la implementación. Puede comprobar el esquema YAML del punto de conexión por lotes completo para obtener propiedades adicionales.

   deployment-ordinal/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-train-xgb
   description: A sample deployment that trains an XGBoost model for the UCI dataset.
   endpoint_name: uci-classifier-train
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Nuestra canalización se define en una función. Para transformarlo en un componente, usará su propiedad component. Los componentes de canalización son gráficos de proceso reutilizables que se pueden incluir en implementaciones por lotes o que se pueden usar para crear canalizaciones más complejas.

   pipeline_component = ml_client.components.create_or_update(
       uci_heart_classifier_trainer().component
   )

   Ahora podemos definir la implementación:

   deployment = PipelineComponentBatchDeployment(
       name="uci-classifier-train-xgb",
       description="A sample deployment that trains an XGBoost model for the UCI dataset.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

2. Creación de la implementación:

   CLI de Azure

   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 --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default
   

   Sugerencia

   Observa el uso de la marca --set-default para indicar que esta nueva implementación es ahora el valor predeterminado.

   Python

   Este comando iniciará la creación de la implementación y devolverá una respuesta de confirmación mientras continúa la creación de la implementación.

   ml_client.batch_deployments.begin_create_or_update(deployment).result()

   Una vez creada, vamos a configurar esta nueva implementación como la predeterminada:

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

3. La implementación está lista para su uso.

Prueba de la implementación

Una vez creada la implementación, está lista para recibir trabajos. Sigue estos pasos para probar lo siguiente:

1. Nuestra implementación requiere que indiquemos una entrada de datos.

   CLI de Azure

   El archivo inputs.yml contiene la definición del recurso de datos de entrada:

   inputs.yml

   inputs:
     input_data:
       type: uri_folder
       path: azureml:heart-classifier-train@latest
   

   Python

   Define el recurso de datos de entrada:

   input_data = Input(type=AssetTypes.URI_FOLDER, path=heart_dataset_train.id)

   Sugerencia

   Para más información sobre cómo indicar entradas, consulta Crear trabajos y datos de entrada para puntos de conexión por lotes.

2. Puedes invocar la implementación determinada de la siguiente manera:

   CLI de Azure

   JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
   

   Python

   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, inputs={"input_data": input_data}
   )

3. Puedes supervisar el progreso de la presentación y transmitir los registros mediante:

   CLI de Azure

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Para esperar a que finalice el trabajo, ejecuta el código siguiente:

   ml_client.jobs.stream(name=job.name)

Cabe mencionar que solo las entradas de la canalización se publican como entradas en el punto de conexión por lotes. Por ejemplo, categorical_encoding es una entrada de un paso de la canalización, pero no una entrada en la propia canalización. Usa este hecho para controlar qué entradas deseas exponer a los clientes y cuáles deseas ocultar.

Obtener acceso a las salidas del trabajo

Una vez completado el trabajo, podemos acceder a algunas de sus salidas. Esta canalización genera las siguientes salidas para sus componentes:

• preprocess job: la salida es transformations_output
• train job: las salidas son model y evaluation_results

Puedes descargar los resultados asociados mediante:

CLI de Azure

az ml job download --name $JOB_NAME --output-name transformations
az ml job download --name $JOB_NAME --output-name model
az ml job download --name $JOB_NAME --output-name evaluation_results

Python

ml_client.jobs.download(
    name=job.name, download_path=".", output_name="transformations_output"
)
ml_client.jobs.download(name=job.name, download_path=".", output_name="model")
ml_client.jobs.download(
    name=job.name, download_path=".", output_name="evaluation_results"
)

Crear una nueva implementación en el punto de conexión

Los puntos de conexión pueden hospedar varias implementaciones a la vez, al tiempo que mantienen una sola implementación como valor predeterminado. Por lo tanto, puedes iterar en los distintos modelos, implementar los distintos modelos en el punto de conexión y probarlos y, por último, cambiar la implementación predeterminada a la implementación de modelo que funciona mejor para ti.

Vamos a cambiar la forma en que se realiza el preprocesamiento en la canalización para ver si se obtiene un modelo que funciona mejor.

Cambio de un parámetro en el componente de preprocesamiento de la canalización

El componente de preprocesamiento tiene una entrada que se llama categorical_encoding, que puede tener valores ordinal o onehot. Estos valores corresponden a dos formas diferentes de codificar características de categorías.

• ordinal: codifica los valores de características con valores numéricos (ordinal) de [1:n], donde n es el número de categorías de la característica. La codificación ordinal implica que hay un orden de clasificación natural entre las categorías de características.
• onehot: no implica una relación ordenada de clasificación natural, pero presenta un problema de dimensionalidad si el número de categorías es grande.

De forma predeterminada, usamos ordinal anteriormente. Ahora vamos a cambiar la codificación categórica para usar onehot y ver cómo funciona el modelo.

Sugerencia

Como alternativa, podríamos haber expuesto la entrada categorial_encoding a los clientes como entrada para el propio trabajo de canalización. Sin embargo, decidimos cambiar el valor del parámetro en el paso de preprocesamiento para que podamos ocultar y controlar el parámetro dentro de la implementación y aprovechar la oportunidad de tener varias implementaciones en el mismo punto de conexión.

1. Modificar la canalización. Tiene el siguiente aspecto:

   CLI de Azure

   La configuración de la canalización se define en el archivo deployment-onehot/pipeline.yml:

   deployment-onehot/pipeline.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
   type: pipeline
   
   name: uci-heart-train-pipeline
   display_name: uci-heart-train
   description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.
   
   inputs:
     input_data:
       type: uri_folder
   
   outputs: 
     model:
       type: mlflow_model
       mode: upload
     evaluation_results:
       type: uri_folder
       mode: upload
     prepare_transformations:
       type: uri_folder
       mode: upload
   
   jobs:
     preprocess_job:
       type: command
       component: ../components/prepare/prepare.yml
       inputs:
         data: ${{parent.inputs.input_data}}
         categorical_encoding: onehot
       outputs:
         prepared_data:
         transformations_output: ${{parent.outputs.prepare_transformations}}
     
     train_job:
       type: command
       component: ../components/train_xgb/train_xgb.yml
       inputs:
         data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
         target_column: target
         eval_size: 0.3
       outputs:
         model: 
           type: mlflow_model
           path: ${{parent.outputs.model}}
         evaluation_results:
           type: uri_folder
           path: ${{parent.outputs.evaluation_results}}
   

   Python

   @pipeline()
   def uci_heart_classifier_onehot(input_data: Input(type=AssetTypes.URI_FOLDER)):
       prepared_data = prepare_data(data=input_data, categorical_encoding="onehot")
       trained_model = train_xgb(
           data=prepared_data.outputs.prepared_data,
           target_column="target",
           register_best_model=False,
           eval_size=0.3,
       )
   
       return {
           "model": trained_model.outputs.model,
           "evaluation_results": trained_model.outputs.evaluation_results,
           "transformations_output": prepared_data.outputs.transformations_output,
       }

2. Configurar la implementación:

   CLI de Azure

   El archivo deployment-onehot/deployment.yml contiene la configuración de la implementación. Puede comprobar el esquema YAML del punto de conexión por lotes completo para obtener propiedades adicionales.

   deployment-onehot/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-train-onehot
   description: A sample deployment that trains an XGBoost model for the UCI dataset using onehot encoding for variables.
   endpoint_name: uci-classifier-train
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Nuestra canalización se define en una función. Para transformarlo en un componente, usarás el método build(). Los componentes de canalización son gráficos de proceso reutilizables que se pueden incluir en implementaciones por lotes o que se pueden usar para crear canalizaciones más complejas.

   pipeline_component = uci_heart_classifier_onehot._pipeline_builder.build()

   Ahora podemos definir la implementación:

   deployment_onehot = PipelineComponentBatchDeployment(
       name="uci-classifier-train-onehot",
       description="A sample deployment that trains an XGBoost model for the UCI dataset with one hot encoding of categorical variables.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

3. Creación de la implementación:

   CLI de Azure

   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 --endpoint $ENDPOINT_NAME -f deployment-onehot/deployment.yml
   

   La implementación está lista para su uso.

   Python

   Este comando iniciará la creación de la implementación y devolverá una respuesta de confirmación mientras continúa la creación de la implementación.

   ml_client.batch_deployments.begin_create_or_update(deployment_onehot).result()

4. La implementación está lista para su uso.

Prueba de una implementación no predeterminada

Una vez creada la implementación, está lista para recibir trabajos. Podemos probarlo de la misma manera que hicimos antes, pero ahora invocaremos una implementación específica:

1. Invoca la implementación de la siguiente manera, especificando el parámetro de implementación para desencadenar la implementación específica uci-classifier-train-onehot:

   CLI de Azure

   DEPLOYMENT_NAME="uci-classifier-train-onehot"
   JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME -d $DEPLOYMENT_NAME --f inputs.yml --query name -o tsv)
   

   Python

   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_onehot.name,
       inputs={"input_data": input_data},
   )

2. Puedes supervisar el progreso de la presentación y transmitir los registros mediante:

   CLI de Azure

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(name=job.name)

   Para esperar a que finalice el trabajo, ejecuta el código siguiente:

   ml_client.jobs.stream(name=job.name)

Configurar la nueva implementación como la predeterminada

Una vez satisfechos con el rendimiento de la nueva implementación, podemos establecer este nuevo como predeterminado:

CLI de Azure

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

Python

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

Eliminar la implementación antigua

Una vez que hayas terminado, podrás eliminar la implementación anterior si ya no la necesitas:

CLI de Azure

az ml batch-deployment delete --name uci-classifier-train-xgb --endpoint-name $ENDPOINT_NAME --yes

Python

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

Limpieza de recursos

Una vez que hayas terminado, elimina los recursos asociados del área de trabajo:

CLI de Azure

Ejecuta el código siguiente para eliminar el punto de conexión por lotes y la implementación subyacente. --yes se usa para confirmar la eliminación.

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

Python

Eliminación del punto de conexión:

ml_client.batch_endpoints.begin_delete(endpoint_name).result()

(Opcional) elimina el proceso, a menos que planees reutilizar el clúster de proceso con implementaciones posteriores.

CLI de Azure

az ml compute delete -n batch-cluster

Python

ml_client.compute.begin_delete(name="batch-cluster")

Pasos siguientes

• Cómo implementar una canalización para realizar puntuaciones por lotes con preprocesamiento
• Crear puntos de conexión por lotes a partir de trabajos de canalización
• Acceso a datos desde trabajos de puntos de conexión por lotes
• Solución de problemas de puntos de conexión por lotes