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

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Neste artigo, você aprenderá como operacionalizar um pipeline de treinamento sob 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.

Ficará a saber como:

• 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
• Teste a nova implantação e defina-a 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 UCI Heart Disease Data set para treinar um modelo XGBoost. Usamos um componente de pré-processamento de dados para pré-processar os dados antes de serem enviados para o componente de treinamento para ajustar e avaliar o modelo.

Uma visualização do pipeline é a seguinte:

O exemplo neste artigo é baseado em exemplos de código contidos no repositório azureml-examples . Para executar os comandos localmente sem ter que copiar/colar YAML e outros arquivos, primeiro clone o repositório e, em seguida, altere os diretórios para a pasta:

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

Os arquivos para este exemplo estão em:

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

Acompanhe nos cadernos Jupyter

Você pode acompanhar a versão do SDK do Python deste exemplo abrindo o bloco de anotações sdk-deploy-and-test.ipynb no repositório clonado.

Pré-requisitos

• Uma subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.

• Uma área de trabalho do Azure Machine Learning. Para criar um espaço de trabalho, consulte Gerenciar espaços de trabalho do Azure Machine Learning.

• Verifique se você tem as seguintes permissões no espaço de trabalho Aprendizado de Máquina:

  • Criar ou gerenciar pontos de extremidade em lote e implantações: use uma função Proprietário, Colaborador ou Personalizada que permita Microsoft.MachineLearningServices/workspaces/batchEndpoints/*o .
  • Criar implantações do Azure Resource Manager no grupo de recursos do espaço de trabalho: use uma função Proprietário, Colaborador ou Personalizada que permita Microsoft.Resources/deployments/write a entrada no grupo de recursos onde o espaço de trabalho está implantado.

• Instale o seguinte software para trabalhar com Machine Learning:

  CLI do Azure

  Execute o seguinte comando para instalar a CLI do Azure e a extensão para o ml Azure Machine Learning:

  az extension add -n ml
  

  As implantações de componentes de pipeline para pontos de extremidade em lote são introduzidas na versão 2.7 da ml extensão para a CLI do Azure. Use o az extension update --name ml comando para obter a versão mais recente.

  Python

  Execute o seguinte comando para instalar o SDK do Azure Machine Learning para Python:

  pip install azure-ai-ml
  

  As ModelBatchDeployment classes e PipelineComponentBatchDeployment são introduzidas na versão 1.7.0 do SDK. Use o pip install -U azure-ai-ml comando para obter a versão mais recente.

---

Ligar à sua área de trabalho

O espaço de trabalho é o recurso de nível superior para Machine Learning. Ele fornece um local centralizado para trabalhar com todos os artefatos que você cria quando usa o Machine Learning. Nesta seção, você se conecta ao espaço de trabalho onde executa suas tarefas de implantação.

CLI do Azure

No comando a seguir, insira os valores para sua ID de assinatura, espaço de trabalho, local e grupo de recursos:

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

Python

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

2. Configure os detalhes do espaço de trabalho e obtenha um identificador para o espaço de trabalho:

   No comando a seguir, insira os valores para sua ID de assinatura, espaço de trabalho e grupo de recursos:

   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 inclua 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, finalmente, registraremos os dados de entrada como um ativo de dados.

Criar o ambiente

Os componentes neste exemplo usarão um ambiente com as XGBoost bibliotecas e scikit-learn . O environment/conda.yml arquivo 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:

1. Defina o ambiente:

   CLI do Azure

   ambiente/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. Crie o ambiente:

   CLI do Azure

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

   Python

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

Criar um cluster de computação

Pontos de extremidade em lote e implantações são executados em clusters de computação. Eles podem ser executados em qualquer cluster de computação do Azure Machine Learning que já exista no espaço de trabalho. Portanto, várias implantações em lote podem compartilhar a mesma infraestrutura de computação. Neste exemplo, trabalharemos em um cluster de computação do Azure Machine Learning chamado batch-cluster. Vamos verificar se a computação existe no espaço de trabalho ou criá-la de outra forma.

CLI do 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 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 mais de nível de produção, vamos registrar os heart.csv dados de treinamento no arquivo como um ativo de dados no espaço de trabalho. Esse ativo de dados será posteriormente indicado como uma entrada para o ponto de extremidade.

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

Crie o ativo de dados:

ml_client.data.create_or_update(heart_dataset_train)

Vamos obter uma referência ao 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 consiste em 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 a partir dos dados de entrada. Como a transformations entrada é opcional, o componente pode ser usado durante o preprocess_job treinamento e pontuação.
  • categorical_encoding: a estratégia de codificação para as características categóricas (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é-tratados.
  • target_column: a coluna que queremos prever.
  • eval_size: indica a proporção dos dados de cálculo utilizados para a avaliação.

CLI do Azure

A configuração do pipeline é definida no deployment-ordinal/pipeline.yml arquivo:

implantação-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

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

Python

As configurações para os componentes do prepare.yml pipeline estão nos arquivos 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,
    }

Nota

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

Uma visualização do pipeline é a seguinte:

Testar o pipeline

Vamos testar o pipeline com alguns dados de exemplo. Para fazer isso, criaremos um trabalho usando o pipeline e o cluster de batch-cluster computação criado anteriormente.

CLI do Azure

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

implantação-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)
)

Agora, vamos definir 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

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

Criar um ponto de extremidade em lote

1. 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 quaisquer caracteres à direita ao nome especificado no código a seguir.

   CLI do Azure

   ENDPOINT_NAME="uci-classifier-train"
   

   Python

   endpoint_name = "uci-classifier-train"

2. Configure o ponto de extremidade:

   CLI do Azure

   O endpoint.yml arquivo 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
   

   Python

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

3. Crie o ponto de extremidade:

   CLI do Azure

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

   Python

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

4. Consulte o URI do ponto de extremidade:

   CLI do Azure

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

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

Implantar o componente de pipeline

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

1. Configure a implantação:

   CLI do Azure

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

   implantação-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

   Nosso pipeline é definido em uma função. Para transformá-lo em um componente, você usará a component propriedade dele. Os componentes de pipeline são gráficos 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},
   )

2. Crie a implantação:

   CLI do Azure

   Execute o código a seguir para criar uma implantação em lote no ponto de extremidade em lote e defini-la como a implantação padrão.

   az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default
   

   Gorjeta

   Observe o --set-default uso do sinalizador para indicar que essa nova implantação agora é o padrão.

   Python

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

   Uma vez criada, vamos configurar essa nova implantação como 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()

3. Sua implantação está pronta para uso.

Testar a implementação

Depois que a implantação é criada, ela está pronta para receber trabalhos. Siga estas etapas para testá-lo:

1. Nossa implantação requer que indiquemos uma entrada de dados.

   CLI do Azure

   O inputs.yml arquivo contém a definição para o ativo de dados de entrada:

   inputs.yml

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

   Python

   Defina o ativo de dados de entrada:

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

   Gorjeta

   Para saber mais sobre como indicar entradas, consulte Criar trabalhos e dados de entrada para pontos de extremidade em lote.

2. Você pode invocar a implantação padrão da seguinte maneira:

   CLI do Azure

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

   Python

   Gorjeta

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

   Em geral, você pode usar um parâmetro de dicionário inputs = {} com o invoke método 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 input parâmetro como uma maneira mais curta de especificar o local dos dados de entrada para a implantação. Essa abordagem funciona porque uma implantação de modelo sempre usa apenas uma entrada de dados.

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name, inputs={"input_data": input_data}
   )

3. Você pode monitorar o progresso do show e transmitir os logs usando:

   CLI do Azure

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Para aguardar a conclusão do trabalho, execute o seguinte código:

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

Vale a pena mencionar que apenas as entradas do pipeline são publicadas como entradas no endpoint do 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

Uma vez que o trabalho é concluído, podemos acessar algumas de suas 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

Você pode baixar os resultados associados usando:

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

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 sobre seus diferentes modelos, implantar os diferentes modelos em seu ponto de extremidade e testá-los e, finalmente, alternar a implantação padrão para a implantação de modelo que funciona melhor para você.

Vamos mudar a forma 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 características categóricas.

• ordinal: Codifica os valores do recurso com valores numéricos (ordinais) de [1:n], onde 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 natural ordenada por classificação, mas introduz um problema de dimensionalidade se o número de categorias for grande.

Por padrão, usamos ordinal anteriormente. Vamos agora alterar a codificação categórica para usar onehot e ver como o modelo funciona.

Gorjeta

Como alternativa, poderíamos ter exposto a categorial_encoding entrada 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 sob o mesmo ponto de extremidade.

1. Modifique o pipeline. Tem a seguinte aparência:

   CLI do Azure

   A configuração do pipeline é definida no deployment-onehot/pipeline.yml arquivo:

   implantação-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. Configure a implantação:

   CLI do Azure

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

   implantação-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

   Nosso pipeline é definido em uma função. Para transformá-lo em um componente, você usará o build() método. Os componentes de pipeline são gráficos 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},
   )

3. Crie a implantação:

   CLI do Azure

   Execute o código a seguir para criar uma implantação em lote no ponto de extremidade em lote e defini-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.

   Python

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

4. Sua implantação está pronta para uso.

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

Depois que a implantação é criada, ela está pronta para receber trabalhos. Podemos testá-lo da mesma forma que fazíamos antes, mas agora vamos invocar uma implantação específica:

1. Invoque a implantação da seguinte maneira, especificando o parâmetro de implantação para disparar a implantação uci-classifier-train-onehotespecífica:

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

   Gorjeta

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

   Em geral, você pode usar um parâmetro de dicionário inputs = {} com o invoke método 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 input parâmetro como uma maneira mais curta de especificar o local dos dados de entrada para a implantação. Essa abordagem funciona porque uma implantação de modelo sempre usa 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},
   )

2. Você pode monitorar o progresso do show e transmitir os logs usando:

   CLI do Azure

   az ml job stream -n $JOB_NAME
   

   Python

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

   Para aguardar a conclusão do trabalho, execute o seguinte código:

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

Configurar a nova implantação como padrão

Quando estivermos satisfeitos com o desempenho da nova implantação, podemos definir esta nova como padrão:

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

Excluir a implantação antiga

Quando terminar, você pode excluir a implantação antiga se não precisar mais dela:

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

Clean up resources (Limpar recursos)

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

CLI do Azure

Execute o código a seguir para excluir o ponto de extremidade em lote e sua implantação subjacente. --yes é utilizado para confirmar a eliminação.

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

Python

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 computação com implantações posteriores.

CLI do Azure

az ml compute delete -n batch-cluster

Python

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

Próximos passos

• Como implantar um pipeline para executar a pontuação em lote com pré-processamento
• Criar pontos de extremidade em lote a partir de trabalhos de pipeline
• Acessando dados de trabalhos de pontos de extremidade em lote
• Resolver problemas com pontos finais em lote