Como operacionalizar um pipeline de treinamento com pontos de extremidade em lote

Artigo
09/03/2024

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Neste artigo, você aprenderá a operacionalizar um pipeline de treinamento em um ponto de extremidade em lote. O pipeline usa vários componentes (ou etapas) que incluem treinamento de modelo, pré-processamento de dados e avaliação de modelo.

Você aprenderá a:

Criar e testar um pipeline de treinamento
Implantar o pipeline em um ponto de extremidade em lote
Modificar o pipeline e criar uma nova implantação no mesmo ponto de extremidade
Testar a nova implantação e defini-la como a implantação padrão

Sobre este exemplo

Este exemplo implanta um pipeline de treinamento que usa dados de treinamento de entrada (rotulados) e produz um modelo preditivo, juntamente com os resultados da avaliação e as transformações aplicadas durante o pré-processamento. O pipeline usará dados tabulares do Conjunto de Dados de Doenças Cardíacas UCI para treinar um modelo XGBoost. Usamos um componente de pré-processamento de dados para pré-processar os dados antes de serem enviados ao componente de treinamento para ajustar e avaliar o modelo.

Uma visualização do pipeline é da seguinte forma:

O exemplo neste artigo é baseado em exemplos de códigos contidos no repositório azureml-examples . Para executar os comandos localmente sem precisar copiar ou colar YAML e outros arquivos, use os seguintes comandos para clonar o repositório e ir para a pasta de sua linguagem de programação:

CLI do 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

Os arquivos desse exemplo estão em:

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

Acompanhar nos notebooks do Jupyter

Você pode acompanhar a versão do SDK do Python deste exemplo abrindo o notebook sdk-deploy-and-test.ipynb no repositório clonado.

Pré-requisitos

Uma assinatura do Azure. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
Um workspace do Azure Machine Learning. Para criar um workspace, confira Gerenciar workspaces do Azure Machine Learning.
As seguintes permissões no Workspace do Azure Machine Learning:
- Para criar ou gerenciar pontos de extremidade e implantações em lotes: use um Proprietário, Colaborador ou função personalizada que recebeu as permissões de Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Para criar implantações do Azure Resource Manager no grupo de recursos do workspace: use um Proprietário, Colaborador ou função personalizada que recebeu a permissão Microsoft.Resources/deployments/write no grupo de recursos em que o workspace é implantado.
A CLI do Azure Machine Learning ou o SDK do Azure Machine Learning para Python:
- CLI do Azure
- Python
Execute o seguinte comando para instalar a CLI do Azure e a extensão do Azure Machine Learning ml:
```
az extension add -n ml
```
As implantações de componente de pipeline para pontos de extremidade em lote são introduzidas na versão 2.7 da extensão ml da CLI do Azure. Use o comando az extension update --name ml para obter a versão mais recente.
Execute o seguinte comando para instalar o SDK do Azure Machine Learning para Python:
```
pip install azure-ai-ml
```
As classes ModelBatchDeployment e PipelineComponentBatchDeployment são introduzidas na versão 1.7.0 do SDK. Use o comando pip install -U azure-ai-ml para obter a versão mais recente.

Conectar-se ao workspace

O workspace é o recurso de nível superior do Azure Machine Learning. Ele fornece um local centralizado para trabalhar com todos os artefatos criados quando você usa o Azure Machine Learning. Nesta seção, você se conecta ao workspace em que executa as suas tarefas de implantação.

CLI do Azure
Python

No comando a seguir, insira a ID da assinatura, o nome do workspace, o nome do grupo de recursos e o local:

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

Importe as bibliotecas necessárias:

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

Configure os detalhes do espaço de trabalho e gerencie o espaço de trabalho:

No comando a seguir, insira sua ID de assinatura, o nome do grupo de recursos e o nome do workspace:

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

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

Criar o componente de pipeline de treinamento

Nesta seção, criaremos todos os ativos necessários para nosso pipeline de treinamento. Começaremos criando um ambiente que inclui as bibliotecas necessárias para treinar o modelo. Em seguida, criaremos um cluster de computação no qual a implantação em lote será executada e, por fim, registraremos os dados de entrada como um ativo de dados.

Criar o ambiente

Os componentes neste exemplo usarão um ambiente com as bibliotecas XGBoost e scikit-learn. O arquivo environment/conda.yml contém a configuração do ambiente:

ambiente/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

Crie o ambiente da seguinte maneira:

Defina o ambiente:

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

Crie o ambiente:

CLI do Azure
Python

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

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

Criar um cluster de cálculo

Os pontos de extremidade do lote e as implantações são executados em clusters de cálculo. Eles podem ser executados em qualquer cluster de cálculo do Azure Machine Learning que já exista no espaço de trabalho. Portanto, várias implantações em lotes podem compartilhar a mesma infraestrutura de computação. Neste exemplo, vamos trabalhar em um cluster de cálculo do Azure Machine Learning chamado batch-cluster. Vamos verificar se a computação existe no espaço de trabalho ou criá-la, caso não exista.

CLI do 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 os dados de treinamento como um ativo de dados

Nossos dados de treinamento são representados em arquivos CSV. Para imitar uma carga de trabalho de nível de produção, vamos registrar os dados de treinamento no arquivo heart.csv como um ativo de dados no workspace. Esse ativo de dados será indicado posteriormente como uma entrada para o ponto de extremidade.

CLI do 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,
)

Crie o ativo de dados:

ml_client.data.create_or_update(heart_dataset_train)

Vamos obter uma referência para o novo ativo de dados:

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

Criar o pipeline

O pipeline que queremos operacionalizar usa uma entrada, os dados de treinamento e produz três saídas: o modelo treinado, os resultados da avaliação e as transformações de dados aplicadas como pré-processamento. O pipeline é composto por dois componentes:

preprocess_job: esta etapa lê os dados de entrada e retorna os dados preparados e as transformações aplicadas. A etapa recebe três entradas:
- data: uma pasta que contém os dados de entrada para transformar e pontuar
- transformations: (opcional) Caminho para as transformações que serão aplicadas, se disponíveis. Se o caminho não for fornecido, as transformações serão aprendidas com os dados de entrada. Como a entrada transformations é opcional, o componente preprocess_job pode ser usado durante o treinamento e a pontuação.
- categorical_encoding: a estratégia de codificação para os recursos categóricos (ordinal ou onehot).
train_job: esta etapa treinará um modelo XGBoost com base nos dados preparados e retornará os resultados da avaliação e o modelo treinado. A etapa recebe três entradas:
- data: os dados pré-processados.
- target_column: a coluna que desejamos prever.
- eval_size: indica a proporção dos dados de entrada usados para avaliação.

CLI do Azure
Python

A configuração do pipeline é definida no arquivo 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}}

Observação

No arquivo pipeline.yml, a entrada transformations não está no preprocess_job; portanto, o script aprenderá os parâmetros de transformação dos dados de entrada.

As configurações dos componentes de pipeline estão nos arquivos prepare.yml e train_xgb.yml . Carregue os componentes:

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

Construa o pipeline:

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

Observação

No pipeline, a entrada transformations está ausente; portanto, o script aprenderá os parâmetros dos dados de entrada.

Uma visualização do pipeline é da seguinte forma:

Testar o pipeline

Vamos testar o pipeline com alguns dados de exemplo. Para isso, criaremos um trabalho usando o pipeline e o cluster de cálculo batch-cluster criado anteriormente.

CLI do Azure
Python

O arquivo pipeline-job.yml a seguir contém a configuração do trabalho de pipeline:

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

Agora, definiremos algumas configurações de execução para executar o teste:

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

Crie o trabalho de teste:

CLI do 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

Criar um ponto de extremidade em lote

Forneça um nome para o ponto de extremidade. O nome de um ponto de extremidade em lote precisa ser exclusivo em cada região, pois o nome é usado para construir o URI de invocação. Para garantir a exclusividade, acrescente todos os caracteres à direita ao nome especificado no código a seguir.
- CLI do Azure
- Python
```
ENDPOINT_NAME="uci-classifier-train"
```
```
endpoint_name = "uci-classifier-train"
```

Configurar o ponto de extremidade:

CLI do Azure
Python

O arquivo endpoint.yml contém a configuração do ponto de extremidade.

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

Criar o ponto de extremidade:

CLI do Azure
Python

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

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

Consulte o URI do ponto de extremidade:

CLI do Azure
Python

az ml batch-endpoint show --name $ENDPOINT_NAME

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

Implantar o componente de pipeline

Para implantar o componente de pipeline, precisamos criar uma implantação em lote. Uma implantação é um conjunto de recursos necessários para hospedar o ativo que faz o trabalho real.

Configure a implantação:

CLI do Azure
Python

O arquivo deployment-ordinal/deployment.yml contém a configuração da implantação. Você pode verificar o esquema YAML do ponto de extremidade do lote completo para obter propriedades extras.

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

Nosso pipeline é definido em uma função. Para transformá-lo em um componente, você usará sua propriedade component. Os componentes de pipeline são grafos de computação reutilizáveis que podem ser incluídos em implantações em lote ou usados para compor pipelines mais complexos.

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

Agora podemos definir a implantação:

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

Criar a implantação:
- CLI do Azure
- Python
Execute o código a seguir para criar uma implantação em lote sob o ponto de extremidade de lote e defina-la como a implantação padrão.
```
az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default
```
Dica

Observe o uso do sinalizador --set-default para indicar que essa nova implantação agora é a padrão.
Esse comando iniciará a criação da implantação e retornará uma resposta de confirmação enquanto a criação da implantação continuar.
```
ml_client.batch_deployments.begin_create_or_update(deployment).result()
```
Depois de criada, vamos configurar essa nova implantação como a padrão:
```
endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
Sua implantação está pronta para uso.

Teste a implantação

Depois que a implantação for criada, ela estará pronta para receber trabalhos. Siga estas etapas para testá-la:

Nossa implantação requer a indicação de uma entrada de dados.
- CLI do Azure
- Python
O arquivo inputs.yml contém a definição do ativo de dados de entrada:

inputs.yml
```
inputs:
  input_data:
    type: uri_folder
    path: azureml:heart-classifier-train@latest
```
Defina o ativo de dados de entrada:
```
input_data = Input(type=AssetTypes.URI_FOLDER, path=heart_dataset_train.id)
```
Dica

Para saber mais sobre como indicar entradas, confira Criar trabalhos e dados de entrada para pontos de extremidade em lote.
Você pode invocar a implantação padrão da seguinte maneira:
- CLI do Azure
- Python
```
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
```
Dica

Qual é a diferença entre o parâmetro inputs e o parâmetro input quando você invoca um ponto de extremidade?

Em geral, você pode usar um parâmetro inputs = {} de dicionário com o método invoke para fornecer um número arbitrário de entradas necessárias para um ponto de extremidade em lote que contém uma implantação de modelo ou uma implantação de pipeline.

Para uma implantação de modelo, você pode usar o parâmetro input como uma maneira mais curta de especificar o local de dados de entrada para a implantação. Essa abordagem funciona porque uma implantação de modelo sempre aceita apenas uma entrada de dados.
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, inputs={"input_data": input_data}
)
```
Monitore o progresso da exibição e transmita os logs usando:
- CLI do Azure
- Python
```
az ml job stream -n $JOB_NAME
```
```
ml_client.jobs.get(job.name)
```
Para aguardar a conclusão do trabalho, execute o código a seguir:
```
ml_client.jobs.stream(name=job.name)
```

Vale a pena mencionar que apenas as entradas do pipeline são publicadas como entradas no ponto de extremidade em lote. Por exemplo, categorical_encoding é uma entrada de uma etapa do pipeline, mas não uma entrada no pipeline em si. Use esse fato para controlar quais entradas você deseja expor aos seus clientes e quais você deseja ocultar.

Acessar saídas de trabalho

Depois que o trabalho for concluído, poderemos acessar alguma das saídas. Esse pipeline produz as seguintes saídas para seus componentes:

preprocess job: a saída é transformations_output
train job: as saídas são model e evaluation_results

Baixe os resultados associados usando:

CLI do 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"
)

Criar uma nova implantação no ponto de extremidade

Os pontos de extremidade podem hospedar várias implantações ao mesmo tempo, mantendo apenas uma implantação como padrão. Portanto, você pode iterar os seus diferentes modelos, implantar os diferentes modelos em seu ponto de extremidade e testá-los e, por fim, mudar a implantação padrão para a implantação de modelo que funciona melhor para você.

Vamos alterar a maneira como o pré-processamento é feito no pipeline para ver se obtemos um modelo com melhor desempenho.

Alterar um parâmetro no componente de pré-processamento do pipeline

O componente de pré-processamento tem uma entrada chamada categorical_encoding, que pode ter valores ordinal ou onehot. Esses valores correspondem a duas maneiras diferentes de codificar recursos categóricos.

ordinal: codifica os valores de recurso com valores numéricos (ordinal) de [1:n], em que n é o número de categorias no recurso. A codificação ordinal implica que há uma ordem de classificação natural entre as categorias de recursos.
onehot: não implica uma relação ordenada de classificação natural, mas introduz um problema de dimensionalidade se o número de categorias for grande.

Por padrão, usamos ordinal anteriormente. Agora vamos alterar a codificação categórica onehot a ser usada e ver o desempenho do modelo.

Dica

Como alternativa, poderíamos ter exposto a entrada categorial_encoding aos clientes como uma entrada para o trabalho de pipeline em si. No entanto, optamos por alterar o valor do parâmetro na etapa de pré-processamento para que possamos ocultar e controlar o parâmetro dentro da implantação e aproveitar a oportunidade de ter várias implantações no mesmo ponto de extremidade.

Modifique o pipeline. Parece o seguinte:

CLI do Azure
Python

A configuração do pipeline é definida no arquivo 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,
    }

Configure a implantação:

CLI do Azure
Python

O arquivo deployment-onehot/deployment.yml contém a configuração da implantação. Você pode verificar o esquema YAML do ponto de extremidade do lote completo para obter propriedades extras.

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

Nosso pipeline é definido em uma função. Para transformá-lo em um componente, você usará o método build(). Os componentes de pipeline são grafos de computação reutilizáveis que podem ser incluídos em implantações em lote ou usados para compor pipelines mais complexos.

pipeline_component = uci_heart_classifier_onehot._pipeline_builder.build()

Agora podemos definir a implantação:

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

Criar a implantação:
- CLI do Azure
- Python
Execute o código a seguir para criar uma implantação em lote sob o ponto de extremidade de lote e defina-la como a implantação padrão.
```
az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-onehot/deployment.yml
```
Sua implantação está pronta para uso.
Esse comando iniciará a criação da implantação e retornará uma resposta de confirmação enquanto a criação da implantação continuar.
```
ml_client.batch_deployments.begin_create_or_update(deployment_onehot).result()
```
Sua implantação está pronta para uso.

Testar uma implantação não padrão

Depois que a implantação for criada, ela estará pronta para receber trabalhos. Podemos testá-la da mesma maneira que fizemos antes, mas agora invocaremos uma implantação específica:

Invoque a implantação da seguinte maneira, especificando o parâmetro de implantação para disparar a implantação uci-classifier-train-onehot específica:
- CLI do 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)
```
Dica

Qual é a diferença entre o parâmetro inputs e o parâmetro input quando você invoca um ponto de extremidade?

Em geral, você pode usar um parâmetro inputs = {} de dicionário com o método invoke para fornecer um número arbitrário de entradas necessárias para um ponto de extremidade em lote que contém uma implantação de modelo ou uma implantação de pipeline.

Para uma implantação de modelo, você pode usar o parâmetro input como uma maneira mais curta de especificar o local de dados de entrada para a implantação. Essa abordagem funciona porque uma implantação de modelo sempre aceita apenas uma entrada de dados.
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    deployment_name=deployment_onehot.name,
    inputs={"input_data": input_data},
)
```
Monitore o progresso da exibição e transmita os logs usando:
- CLI do Azure
- Python
```
az ml job stream -n $JOB_NAME
```
```
ml_client.jobs.get(name=job.name)
```
Para aguardar a conclusão do trabalho, execute o código a seguir:
```
ml_client.jobs.stream(name=job.name)
```

Configurar a nova implantação como a padrão

Depois de estarmos satisfeitos com o desempenho da nova implantação, podemos definir essa nova como o padrão:

CLI do 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()

Excluir a implantação antiga

Depois de terminar, você poderá excluir a implantação antiga se não precisar mais dela:

CLI do 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()

Limpar os recursos

Quando concluir, exclua os recursos associados do espaço de trabalho:

CLI do Azure
Python

Execute o código a seguir para excluir o ponto de extremidade em lote e todas as implantações subjacentes. --yes é usado para confirmar a exclusão.

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

Exclua o ponto de extremidade:

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

(Opcional) Exclua a computação, a menos que planeje reutilizar seu cluster de cálculo em implantações posteriores.

CLI do Azure
Python

az ml compute delete -n batch-cluster

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

Compartilhar via