Partilhar via

Como implantar um pipeline para executar a pontuação em lote com pré-processamento

  • Artigo

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

Neste artigo, você aprenderá como implantar um pipeline de inferência (ou pontuação) sob um ponto de extremidade em lote. O pipeline executa a pontuação em um modelo registrado enquanto também reutiliza um componente de pré-processamento de quando o modelo foi treinado. A reutilização do mesmo componente de pré-processamento garante que o mesmo pré-processamento seja aplicado durante a pontuação.

Ficará a saber como:

  • Criar um pipeline que reutilize componentes existentes do espaço de trabalho
  • Implantar o pipeline em um ponto de extremidade
  • Consumir previsões geradas pelo pipeline

Sobre este exemplo

Este exemplo mostra como reutilizar o código de pré-processamento e os parâmetros aprendidos durante o pré-processamento antes de usar seu modelo para inferência. Ao reutilizar o código de pré-processamento e os parâmetros aprendidos, podemos garantir que as mesmas transformações (como normalização e codificação de recursos) que foram aplicadas aos dados de entrada durante o treinamento também sejam aplicadas durante a inferência. O modelo utilizado para inferência realizará predições em dados tabulares do UCI Heart Disease Data set.

Uma visualização do pipeline é a seguinte:

Uma captura de tela do pipeline de inferência compreendendo um componente de pontuação ao lado dos resultados e do componente de preparação de um pipeline de treinamento.

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:

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

Os arquivos para este exemplo estão em:

cd endpoints/batch/deploy-pipelines/batch-scoring-with-preprocessing

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

Antes de seguir as etapas neste artigo, verifique se você tem os seguintes 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. Se você não tiver um, use as etapas no artigo Gerenciar espaços de trabalho do Azure Machine Learning para criar um.

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

    • 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 ARM 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 em que o espaço de trabalho está implantado.

  • Você precisa instalar o seguinte software para trabalhar com o Azure Machine Learning:

    A CLI do Azure e a ml extensão do Azure Machine Learning.

    az extension add -n ml

    Nota

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

Ligar à sua área de trabalho

A área de trabalho é o recurso de nível superior do Azure Machine Learning que proporciona um local centralizado para trabalhar com todos os artefactos que cria quando utiliza o Azure Machine Learning. Nesta seção, nos conectaremos ao espaço de trabalho no qual você executará tarefas de implantação.

Passe os valores para sua ID de assinatura, espaço de trabalho, local e grupo de recursos no seguinte código:

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

Criar o pipeline de inferência

Nesta seção, criaremos todos os ativos necessários para nosso pipeline de inferência. Começaremos criando um ambiente que inclua as bibliotecas necessárias para os componentes do pipeline. Em seguida, criaremos um cluster de computação no qual a implantação em lote será executada. Depois, registraremos os componentes, modelos e transformações de que precisamos para construir nosso pipeline de inferência. Finalmente, vamos construir e testar o pipeline.

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
name: mlflow-env

Crie o ambiente da seguinte maneira:

  1. Defina o ambiente:

    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.

  2. Crie o ambiente:

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

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.

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

Registar componentes e modelos

Vamos registrar componentes, modelos e transformações de que precisamos para construir nosso pipeline de inferência. Podemos reutilizar alguns destes ativos para rotinas de treino.

Gorjeta

Neste tutorial, reutilizaremos o modelo e o componente de pré-processamento de um pipeline de treinamento anterior. Você pode ver como eles foram criados seguindo o exemplo Como implantar um pipeline de treinamento com pontos de extremidade em lote.

  1. Registre o modelo a ser usado para previsão:

    az ml model create --name heart-classifier --type mlflow_model --path model

  2. O modelo registrado não foi treinado diretamente em dados de entrada. Em vez disso, os dados de entrada foram pré-processados (ou transformados) antes do treinamento, usando um componente de preparação. Também precisaremos registrar esse componente. Registre o componente de preparação:

    az ml component create -f components/prepare/prepare.yml

    Gorjeta

    Depois de registrar o componente de preparação, agora você pode consultá-lo a partir do espaço de trabalho. Por exemplo, azureml:uci_heart_prepare@latest obterá a última versão do componente de preparação.

  3. Como parte das transformações de dados no componente de preparação, os dados de entrada foram normalizados para centralizar os preditores e limitar seus valores no intervalo de [-1, 1]. Os parâmetros de transformação foram capturados em uma transformação scikit-learn que também podemos registrar para aplicar mais tarde quando tivermos novos dados. Registe a transformação da seguinte forma:

    az ml model create --name heart-classifier-transforms --type custom_model --path transformations

  4. Realizaremos inferências para o modelo registrado, usando outro componente chamado score que calcula as previsões para um determinado modelo. Referenciaremos o componente diretamente de sua definição.

    Gorjeta

    A melhor prática seria registrar o componente e fazer referência a ele a partir do pipeline. No entanto, neste exemplo, vamos fazer referência ao componente diretamente de sua definição para ajudá-lo a ver quais componentes são reutilizados do pipeline de treinamento e quais são novos.

Construa o pipeline

Agora é hora de unir todos os elementos. O pipeline de inferência que implantaremos tem dois componentes (etapas):

  • preprocess_job: Esta etapa lê os dados de entrada e retorna os dados preparados e as transformações aplicadas. A etapa recebe duas entradas:
    • data: uma pasta que contém os dados de entrada para pontuar
    • transformations: (opcional) Caminho para as transformações que serão aplicadas, se disponíveis. Quando fornecidas, as transformações são lidas a partir do modelo indicado no caminho. No entanto, se o caminho não for fornecido, as transformações serão aprendidas a partir dos dados de entrada. Para inferir, no entanto, você não pode aprender os parâmetros de transformação (neste exemplo, os coeficientes de normalização) a partir dos dados de entrada porque você precisa usar os mesmos valores de parâmetros que foram aprendidos durante o treinamento. Como essa entrada é opcional, o componente pode ser usado durante o preprocess_job treinamento e a pontuação.
  • score_job: Esta etapa realizará a inferência nos dados transformados, usando o modelo de entrada. Observe que o componente usa um modelo MLflow para executar inferência. Finalmente, as partituras são escritas no mesmo formato em que foram lidas.

A configuração do pipeline é definida no pipeline.yml arquivo:

pipeline.yml

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

name: batch_scoring_uci_heart
display_name: Batch Scoring for UCI heart
description: This pipeline demonstrates how to make batch inference using a model from the Heart Disease Data Set problem, where pre and post processing is required as steps. The pre and post processing steps can be components reusable from the training pipeline.

inputs:
  input_data:
    type: uri_folder
  score_mode:
    type: string
    default: append

outputs: 
  scores:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: azureml:uci_heart_prepare@latest
    inputs:
      data: ${{parent.inputs.input_data}}
      transformations: 
        path: azureml:heart-classifier-transforms@latest
        type: custom_model
    outputs:
      prepared_data:
  
  score_job:
    type: command
    component: components/score/score.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      model:
        path: azureml:heart-classifier@latest
        type: mlflow_model
      score_mode: ${{parent.inputs.score_mode}}
    outputs:
      scores: 
        mode: upload
        path: ${{parent.outputs.scores}}

Uma visualização do pipeline é a seguinte:

Uma captura de tela do pipeline de inferência mostrando a pontuação em lote com pré-processamento.

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.

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

pipeline-job.yml

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

display_name: uci-classifier-score-job
description: |-
  This pipeline demonstrate how to make batch inference using a model from the Heart \
  Disease Data Set problem, where pre and post processing is required as steps. The \
  pre and post processing steps can be components reused from the training pipeline.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
  score_mode: append
outputs: 
  scores:
    mode: upload

Crie o trabalho de teste:

az ml job create -f pipeline-job.yml --set inputs.input_data.path=data/unlabeled

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.

    ENDPOINT_NAME="uci-classifier-score"

  2. Configure o ponto de extremidade:

    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-score
description: Batch scoring endpoint of the Heart Disease Data Set prediction task.
auth_mode: aad_token

  3. Crie o ponto de extremidade:

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

  4. Consulte o URI do ponto de extremidade:

    az ml batch-endpoint show --name $ENDPOINT_NAME

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. Configurar a implementação

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

    deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
name: uci-classifier-prepros-xgb
endpoint_name: uci-classifier-batch
type: pipeline
component: pipeline.yml
settings:
    continue_on_step_failure: false
    default_compute: batch-cluster

  2. Criar a implantação

    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.yml --set-default

    Gorjeta

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

  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 e uma entrada literal.

    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: data/unlabeled
  score_mode:
    type: string
    default: append
outputs:
  scores:
    type: uri_folder
    mode: upload

    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:

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

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

    az ml job stream -n $JOB_NAME

Acessar saída de trabalho

Uma vez que o trabalho é concluído, podemos acessar sua saída. Este trabalho contém apenas uma saída chamada scores:

Você pode baixar os resultados associados usando az ml job downloado .

az ml job download --name $JOB_NAME --output-name scores

Leia os dados da pontuação:

import pandas as pd
import glob

output_files = glob.glob("named-outputs/scores/*.csv")
score = pd.concat((pd.read_csv(f) for f in output_files))
score

A saída tem a seguinte aparência:

idade sexo ... Thal previsão
0.9338 1 ... 2 0
1.3782 1 ... 3 1
1.3782 1 ... 4 0
-1.954 1 ... 3 0

A saída contém as previsões mais os dados que foram fornecidos ao componente de pontuação , que foi pré-processado. Por exemplo, a coluna age foi normalizada e a coluna thal contém valores de codificação originais. Na prática, você provavelmente deseja produzir apenas a previsão e, em seguida, combiná-la com os valores originais. Esta obra foi deixada ao leitor.

Clean up resources (Limpar recursos)

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

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

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

az ml compute delete -n batch-cluster

Próximos passos