Como implantar um pipeline para executar a pontuação em lote com pré-processamento
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 implantar um pipeline de inferência (ou pontuação) em um ponto de extremidade em lote. O pipeline executa a pontuação em um modelo registrado e, ao mesmo tempo, 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.
Você aprenderá a:
- 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) aplicadas aos dados de entrada durante o treinamento também sejam aplicadas durante a inferência. O modelo usado para inferência executará previsões em dados tabulares do Conjunto de Dados de Doenças Cardíacas da UCI.
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/colar o YAML e outros arquivos, primeiro clone o repositório e altere os diretórios para a pasta:
git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli
Os arquivos desse exemplo estão em:
cd endpoints/batch/deploy-pipelines/batch-scoring-with-preprocessing
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
Antes de seguir as etapas neste artigo, verifique se você tem os seguintes pré-requisitos:
Uma assinatura do Azure. Caso não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.
Um workspace do Azure Machine Learning. Se você não tiver um, use as etapas do artigo Gerenciar espaços de trabalho do Azure Machine Learning para criar um.
Certifique-se de ter as seguintes permissões no espaço de trabalho:
Criar ou gerenciar pontos de extremidade e implantações em lotes: use uma função de Proprietário, Colaborador ou Personalizada que permita
Microsoft.MachineLearningServices/workspaces/batchEndpoints/*
.Criar implantações do ARM no grupo de recursos do espaço de trabalho: use uma função de Proprietário, Colaborador ou Personalizada que permita
Microsoft.Resources/deployments/write
no grupo de recursos em que o espaço de trabalho está implantado.
Você precisa instalar o software a seguir 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
Observação
Implantações de componente de pipeline para Pontos de Extremidade em Lote foram introduzidas na versão 2.7 da extensão
ml
para a CLI do Azure. Useaz extension update --name ml
para obter a última versão.
Conectar-se ao workspace
O workspace é o recurso de nível superior para o Azure Machine Learning. Ele fornece um local centralizado para trabalhar com todos os artefatos que você cria ao usar o Azure Machine Learning. Nesta seção, nos conectaremos ao workspace no qual você executará tarefas de implantação.
Passe os valores para sua ID de assinatura, espaço de trabalho, localização e grupo de recursos no código a seguir:
az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>
Criar 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 inclui as bibliotecas necessárias para os componentes do pipeline. Em seguida, criaremos um cluster de cálculo no qual a implantação em lote será executada. Posteriormente, registraremos os componentes, os modelos e as transformações necessárias para criar nosso pipeline de inferência. Por fim, compilaremos e testaremos o pipeline.
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
name: mlflow-env
Crie o ambiente da seguinte maneira:
Defina o ambiente:
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.
Crie o ambiente:
az ml environment create -f environment/xgboost-sklearn-py38.yml
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.
az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5
Registrar componentes e modelos
Vamos registrar componentes, modelos e transformações que precisamos para criar nosso pipeline de inferência. Podemos reutilizar alguns desses ativos para rotinas de treinamento.
Dica
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.
Registre o modelo a ser usado para previsão:
az ml model create --name heart-classifier --type mlflow_model --path model
O modelo registrado não foi treinado diretamente nos 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
Dica
Depois de registrar o componente de preparação, agora você pode referenciá-lo no espaço de trabalho. Por exemplo,
azureml:uci_heart_prepare@latest
obterá a última versão do componente de preparação.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 posteriormente quando tivermos novos dados. Registre a transformação da seguinte maneira:
az ml model create --name heart-classifier-transforms --type custom_model --path transformations
Executaremos a inferência do modelo registrado, usando outro componente chamado
score
que calcula as previsões para um determinado modelo. Vamos referenciar o componente diretamente de sua definição.Dica
A melhor prática seria registrar o componente e referenciá-lo do pipeline. No entanto, neste exemplo, vamos referenciar o 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.
Criar o pipeline
Agora é hora de associar 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 a serem pontuadotransformations
: (opcional) Caminho para as transformações que serão aplicadas, se disponíveis. Quando fornecidas, as transformações são lidas do modelo indicado no caminho. No entanto, se o caminho não for fornecido, as transformações serão aprendidas com os dados de entrada. No entanto, para inferência, você não pode aprender os parâmetros de transformação (neste exemplo, os coeficientes de normalização) dos dados de entrada porque você precisa usar os mesmos valores de parâmetro que foram aprendidos durante o treinamento. Como essa entrada é opcional, o componentepreprocess_job
pode ser usado durante o treinamento e a pontuação.
score_job
: esta etapa executará a inferência nos dados transformados, usando o modelo de entrada. Observe que o componente usa um modelo do MLflow para executar a inferência. Por fim, as pontuações são gravadas no mesmo formato que foram lidas.
A configuração do pipeline é definida no arquivo pipeline.yml
:
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 é 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.
O arquivo pipeline-job.yml
a seguir contém a configuração do 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
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.
ENDPOINT_NAME="uci-classifier-score"
Configurar o ponto de extremidade:
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-score description: Batch scoring endpoint of the Heart Disease Data Set prediction task. auth_mode: aad_token
Criar o ponto de extremidade:
az ml batch-endpoint create --name $ENDPOINT_NAME -f endpoint.yml
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, 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.
Configurar a implantação
O arquivo
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.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
Criar a implantação
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.yml --set-default
Dica
Observe o uso do sinalizador
--set-default
para indicar que essa nova implantação agora é a padrão.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 e uma entrada literal.
O arquivo
inputs.yml
contém a definição do 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
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:
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
Monitore o progresso da exibição e transmita os logs usando:
az ml job stream -n $JOB_NAME
Acessar saída do trabalho
Depois que o trabalho for concluído, poderemos acessar sua saída. Este trabalho contém apenas uma saída chamada scores
:
Baixe os resultados associados usando az ml job download
.
az ml job download --name $JOB_NAME --output-name scores
Leia os dados pontuados:
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:
age | sexo | ... | thal | prediction |
---|---|---|---|---|
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 e 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 gerar apenas a previsão e, em seguida, concatená-la aos valores originais. Esse trabalho é reservado para o leitor.
Limpar os recursos
Quando concluir, exclua os recursos associados do espaço de trabalho:
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
(Opcional) Exclua a computação, a menos que planeje reutilizar seu cluster de cálculo em implantações posteriores.
az ml compute delete -n batch-cluster