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

Artículo
12/26/2023

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 de forma local sin tener que copiar/pegar YAML y otros archivos, primero clona el repositorio y luego cambia los directorios a la carpeta:

CLI de Azure
Python

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

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.

Prerrequisitos

Antes de seguir los pasos de 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 tiene una, siga los pasos descritos en el artículo Administración de áreas de trabajo de Azure Machine Learning para crear una.
Asegúrese de tener los permisos siguientes en el área de trabajo:
- Creación o administración de implementaciones y puntos de conexión por lotes: usar un rol de Propietario, Colaborador o Personalizado que permita Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Creación de implementaciones de ARM en el grupo de recursos del área de trabajo: use un rol Propietario, Colaborador o Personalizado que permita Microsoft.Resources/deployments/write en el grupo de recursos donde se implemente el área de trabajo.
Debe instalar el siguiente software para trabajar con Azure Machine Learning:
- CLI de Azure
- Python
La CLI de Azure y la mlextensión para Azure Machine Learning.
```
az extension add -n ml
```
Nota

Las implementaciones de componentes de canalización para puntos de conexión de Batch se introdujeron en la versión 2.7 de la extensión ml para la CLI de Azure. Use az extension update --name ml para obtener la última versión.
El SDK de Azure Machine Learning para Python.
```
pip install azure-ai-ml
```
Nota

Las clases ModelBatchDeployment y PipelineComponentBatchDeployment se introdujeron en la versión 1.7.0 del SDK. Use pip install -U azure-ai-ml para obtener la última versión.

Conexión con su área de trabajo

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, nos conectaremos al área de trabajo en la que realizará las tareas de implementación.

CLI de Azure
Python

Pasa los valores del id. de suscripción, el área de trabajo, la ubicación y el grupo de recursos en el código siguiente:

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

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

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

Pasa los valores del id. de suscripción, el área de trabajo y el grupo de recursos en el código siguiente:
```
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:

Definir el entorno:

CLI de Azure
Python

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.

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",
)

Crear el entorno:

CLI de Azure
Python

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

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
Python

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="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
Python

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

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
Python

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.

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
Python

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

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
Python

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

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

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
- Python
```
ENDPOINT_NAME="uci-classifier-train"
```
```
endpoint_name = "uci-classifier-train"
```

Configuración del punto de conexión:

CLI de Azure
Python

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

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

Creación del punto de conexión:

CLI de Azure
Python

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

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

Consulta del URI del punto de conexión:

CLI de Azure
Python

az ml batch-endpoint show --name $ENDPOINT_NAME

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.

Configurar la implementación:

CLI de Azure
Python

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

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},
)

Creación de la implementación:
- CLI de Azure
- Python
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.
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()
```
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:

Nuestra implementación requiere que indiquemos una entrada de datos.
- CLI de Azure
- Python
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
```
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.
Puedes invocar la implementación determinada de la siguiente manera:
- CLI de Azure
- Python
```
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
```
Sugerencia

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

En general, se puede usar un diccionario inputs = {} con el método invoke para proporcionar un número arbitrario de entradas necesarias para 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 input como una manera más corta de especificar la ubicación de datos de entrada para la implementación, ya que una implementación del modelo siempre toma una sola entrada de datos.
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, inputs={"input_data": input_data}
)
```
Puedes supervisar el progreso de la presentación y transmitir los registros mediante:
- CLI de Azure
- Python
```
az ml job stream -n $JOB_NAME
```
```
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
Python

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

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.

Modificar la canalización. Tiene el siguiente aspecto:

CLI de Azure
Python

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}}

@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,
    }

Configurar la implementación:

CLI de Azure
Python

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

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},
)

Creación de la implementación:
- CLI de Azure
- Python
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.
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()
```
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:

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
- Python
```
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)
```
Sugerencia

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

En general, se puede usar un diccionario inputs = {} con el método invoke para proporcionar un número arbitrario de entradas necesarias para 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 input como una manera más corta de especificar la ubicación de datos de entrada para la implementación, ya que una implementación del modelo siempre toma una sola entrada de datos.
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    deployment_name=deployment_onehot.name,
    inputs={"input_data": input_data},
)
```
Puedes supervisar el progreso de la presentación y transmitir los registros mediante:
- CLI de Azure
- Python
```
az ml job stream -n $JOB_NAME
```
```
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
Python

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

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

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
Python

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

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
Python

az ml compute delete -n batch-cluster

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