Implantar modelos para pontuação em pontos de extremidade em lote

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

Os endpoints de lote permitem implantar modelos que processam inferência em grandes volumes de dados. Esses endpoints simplificam os modelos de hospedagem para pontuação em lote, para que você possa se concentrar no aprendizado de máquina em vez da infraestrutura.

Utilize pontos de extremidade em lote para implantar modelos quando:

• Você usa modelos caros que levam mais tempo para executar a inferência.
• Você executa inferência sobre grandes quantidades de dados distribuídos em vários arquivos.
• Você não precisa de baixa latência.
• Você beneficia-se da paralelização.

Este artigo mostra como usar um endpoint em lote para implantar um modelo de aprendizado de máquina que resolve o problema clássico de reconhecimento de dígitos MNIST (Modified National Institute of Standards and Technology). O modelo implantado executa a inferência em lote sobre grandes quantidades de dados, como arquivos de imagem. O processo começa com a criação de uma implantação em lote de um modelo construído usando Torch. Essa implantação torna-se o padrão no ponto de extremidade. Mais tarde, crie uma segunda implantação de um modelo criado com o TensorFlow (Keras), teste a segunda implantação e defina-a como a implantação padrão do ponto de extremidade.

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 Como gerenciar espaços de trabalho para criar um.

• Para executar as seguintes tarefas, verifique se você tem essas permissões no espaço de trabalho:

  • Para criar/gerenciar pontos de extremidade e implantações em lote: use a função de proprietário, a função de colaborador ou uma função personalizada que permita Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

  • Para criar implantações ARM no grupo de recursos do espaço de trabalho: use a função de proprietário, a função de colaborador ou uma função personalizada que permita Microsoft.Resources/deployments/write a entrada do 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:

  • CLI do Azure
  • Píton
  • Estúdio

  APLICA-SE A: Azure CLI ml extension v2 (atual)

  A CLI do Azure e a mlextensão do Azure Machine Learning.

  az extension add -n ml
  

Clone o repositório de exemplos

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/endpoints/batch/deploy-models/mnist-classifier

!git clone https://github.com/Azure/azureml-examples --depth 1
!cd azureml-examples/sdk/python/endpoints/batch/deploy-models/mnist-classifier

Prepare o seu sistema

Ligar à sua área de trabalho

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

Criar computação

Os pontos de extremidade em lote são executados em clusters de computação e dão suporte a clusters de computação do Azure Machine Learning (AmlCompute) e clusters Kubernetes. Os clusters são um recurso compartilhado, portanto, um cluster pode hospedar uma ou várias implantações em lote (junto com outras cargas de trabalho, se desejado).

Crie um cálculo chamado batch-cluster, conforme mostrado no código a seguir. Ajuste conforme necessário e faça referência ao seu sistema usando azureml:<your-compute-name>.

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="CPU cluster compute",
        min_instances=0,
        max_instances=2,
    )
    ml_client.compute.begin_create_or_update(compute_cluster).result()

Criar um ponto de extremidade em lote

Um endpoint de lote é um endpoint HTTPS que os clientes usam para iniciar um trabalho de pontuação em lote. Um processo de pontuação em lote pontua várias entradas. Uma implantação em lote é um conjunto de recursos de computação que acomoda o modelo que realiza a pontuação em lote (ou inferência em lote). Um ponto de extremidade de lote pode ter várias implantações em lote. Para obter mais informações sobre pontos de extremidade em lote, consulte O que são pontos de extremidade em lote?.

1. Nomeie o ponto de extremidade. O nome do ponto de extremidade deve ser exclusivo dentro de uma região do Azure porque o nome está incluído no URI do ponto de extremidade. Por exemplo, pode haver apenas um ponto de extremidade em lote com o nome mybatchendpoint em westus2.

   • CLI do Azure
   • Píton
   • Estúdio

   Coloque o nome do ponto de extremidade em uma variável para fazer referência a ele facilmente mais tarde.

   ENDPOINT_NAME="mnist-batch"
   

2. Configurar o ponto de extremidade em lote

   • CLI do Azure
   • Píton
   • Estúdio

   O seguinte arquivo YAML define um ponto de extremidade em lote. Use este ficheiro com o comando CLI para a criação de endpoints em lote.

   endpoint.yml

   $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
   name: mnist-batch
   description: A batch endpoint for scoring images from the MNIST dataset.
   tags:
     type: deep-learning
   

   A tabela a seguir descreve as principais propriedades do ponto de extremidade. Para obter o esquema YAML de ponto de extremidade em lote completo, consulte Esquema YAML de ponto de extremidade em lote CLI (v2).

   Chave	Descrição
   name	O nome do ponto de extremidade do lote. Precisa ser exclusivo no nível da região do Azure.
   description	A descrição do ponto de extremidade do lote. Esta propriedade é opcional.
   tags	As tags a serem incluídas no ponto de extremidade. Esta propriedade é opcional.

3. Crie o ponto de extremidade:

   • CLI do Azure
   • Píton
   • Estúdio

   Execute este código para criar um endpoint de processamento em lote.

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

Criar uma implantação em lote

Uma implantação de modelo é um conjunto de recursos necessários para hospedar o modelo que faz a inferência real. Para criar uma implantação de modelo em lote, você precisa dos seguintes itens:

• Um modelo registrado no espaço de trabalho
• O código para pontuar o modelo
• Um ambiente com as dependências do modelo instaladas
• As configurações de computação e recursos precriadas

1. Comece registrando o modelo a ser implantado — um modelo Torch para o popular problema de reconhecimento de dígitos (MNIST). As implantações em lote só podem implantar modelos registrados no espaço de trabalho. Você pode pular esta etapa se o modelo que deseja implantar já estiver registrado.

   Gorjeta

   Os modelos são associados à implantação, em vez de ao ponto de extremidade. Isso significa que um único ponto de extremidade pode servir diferentes modelos (ou versões de modelo) sob o mesmo ponto de extremidade, desde que os diferentes modelos (ou versões de modelo) sejam implantados em implantações diferentes.

   • CLI do Azure
   • Píton
   • Estúdio

   MODEL_NAME='mnist-classifier-torch'
   az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"
   

2. Agora é hora de criar um script de pontuação. As implantações em lote exigem um script de pontuação que indica como um determinado modelo deve ser executado e como os dados de entrada devem ser processados. Os endpoints em lote suportam scripts criados em Python. Nesse caso, você implanta um modelo que lê arquivos de imagem que representam dígitos e gera o dígito correspondente. O guião de pontuação é o seguinte:

   Nota

   Para modelos MLflow, o Azure Machine Learning gera automaticamente o script de pontuação, portanto, você não precisa fornecer um. Se o seu modelo for um modelo MLflow, você poderá ignorar esta etapa. Para obter mais informações sobre como os pontos de extremidade em lote funcionam com modelos MLflow, consulte o artigo Usando modelos MLflow em implantações em lote.

   Aviso

   Se você estiver implantando um modelo de aprendizado de máquina automatizado (AutoML) em um ponto de extremidade em lote, observe que o script de pontuação que o AutoML fornece funciona apenas para pontos de extremidade online e não foi projetado para execução em lote. Para obter informações sobre como criar um script de pontuação para sua implantação em lote, consulte Criar scripts de pontuação para implantações em lote.

   implantação-tocha/código/batch_driver.py

   import os
   import pandas as pd
   import torch
   import torchvision
   import glob
   from os.path import basename
   from mnist_classifier import MnistClassifier
   from typing import List
   
   
   def init():
       global model
       global device
   
       # AZUREML_MODEL_DIR is an environment variable created during deployment
       # It is the path to the model folder
       model_path = os.environ["AZUREML_MODEL_DIR"]
       model_file = glob.glob(f"{model_path}/*/*.pt")[-1]
   
       model = MnistClassifier()
       model.load_state_dict(torch.load(model_file))
       model.eval()
   
       device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
   
   
   def run(mini_batch: List[str]) -> pd.DataFrame:
       print(f"Executing run method over batch of {len(mini_batch)} files.")
   
       results = []
       with torch.no_grad():
           for image_path in mini_batch:
               image_data = torchvision.io.read_image(image_path).float()
               batch_data = image_data.expand(1, -1, -1, -1)
               input = batch_data.to(device)
   
               # perform inference
               predict_logits = model(input)
   
               # Compute probabilities, classes and labels
               predictions = torch.nn.Softmax(dim=-1)(predict_logits)
               predicted_prob, predicted_class = torch.max(predictions, axis=-1)
   
               results.append(
                   {
                       "file": basename(image_path),
                       "class": predicted_class.numpy()[0],
                       "probability": predicted_prob.numpy()[0],
                   }
               )
   
       return pd.DataFrame(results)
   

3. Crie um ambiente onde a implantação em lote seja executada. O ambiente deve incluir os pacotes azureml-core e azureml-dataset-runtime[fuse], que são exigidos por pontos de extremidade em lote, além de qualquer dependência que seu código exija para ser executado. Nesse caso, as dependências foram capturadas em um conda.yaml arquivo:

   implantação-tocha/ambiente/conda.yaml

   name: mnist-env
   channels:
     - conda-forge
   dependencies:
     - python=3.8.5
     - pip<22.0
     - pip:
       - torch==1.13.0
       - torchvision==0.14.0
       - pytorch-lightning
       - pandas
       - azureml-core
       - azureml-dataset-runtime[fuse]
   

   Importante

   Os pacotes azureml-core e azureml-dataset-runtime[fuse] são exigidos por implantações em lote e devem ser incluídos nas dependências do ambiente.

   Especifique o ambiente da seguinte forma:

   • CLI do Azure
   • Píton
   • Estúdio

   A definição de ambiente é incluída na própria definição de implantação como um ambiente anônimo. Você vê nas seguintes linhas na implantação:

   environment:
     name: batch-torch-py38
     image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest
     conda_file: environment/conda.yaml
   

4. Vá para a guia Ambientes no menu lateral.

5. Selecione Criar ambientes>personalizados.

   1. Digite o nome do ambiente, neste caso torch-batch-env.

   2. Em Select environment source, selecione Use existing docker image with optional conda file.

   3. Em Caminho da imagem do Registro de contêiner, digite mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.

   4. Selecione Avançar para ir para a seção "Personalizar".

   5. Copie o conteúdo do arquivo deployment-torch/environment/conda.yaml do repositório GitHub para o portal.

6. Selecione Avançar até chegar à "Página de revisão".

7. Selecione Criar e aguarde até que o ambiente esteja pronto.

   ---

   Aviso

   Não há suporte para ambientes com curadoria em implantações em lote. Você precisa especificar seu próprio ambiente. Você sempre pode usar a imagem base de um ambiente com curadoria como sua para simplificar o processo.

8. Criar uma definição de implantação

   • CLI do Azure
   • Píton
   • Estúdio

   implantação-tocha/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
   name: mnist-torch-dpl
   description: A deployment using Torch to solve the MNIST classification dataset.
   endpoint_name: mnist-batch
   type: model
   model:
     name: mnist-classifier-torch
     path: model
   code_configuration:
     code: code
     scoring_script: batch_driver.py
   environment:
     name: batch-torch-py38
     image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest
     conda_file: environment/conda.yaml
   compute: azureml:batch-cluster
   resources:
     instance_count: 1
   settings:
     max_concurrency_per_instance: 2
     mini_batch_size: 10
     output_action: append_row
     output_file_name: predictions.csv
     retry_settings:
       max_retries: 3
       timeout: 30
     error_threshold: -1
     logging_level: info
   

   A tabela a seguir descreve as principais propriedades da implantação em lote. Para obter o esquema YAML de implantação em lote completo, consulte Esquema YAML de implantação em lote CLI (v2).

   Chave	Descrição
   name	O nome da implantação.
   endpoint_name	O nome do ponto de extremidade sob o qual criar a implantação.
   model	O modelo a ser usado para a pontuação de lote. O exemplo define um modelo embutido usando path. Esta definição permite que os ficheiros de modelo sejam automaticamente carregados e registados com um nome e uma versão gerados automaticamente. Consulte o esquema Modelo para obter mais opções. Como prática recomendada para cenários de produção, você deve criar o modelo separadamente e consultá-lo aqui. Para fazer referência a um modelo existente, use a azureml:<model-name>:<model-version> sintaxe.
   code_configuration.code	O diretório local que contém todo o código-fonte Python para pontuar o modelo.
   code_configuration.scoring_script	O arquivo Python no code_configuration.code diretório. Este arquivo deve ter uma init() função e uma run() função. Use a função para qualquer preparação cara init() ou comum (por exemplo, para carregar o modelo na memória). init() é chamado apenas uma vez no início do processo. Use run(mini_batch) para pontuar cada entrada, o valor de é uma lista de caminhos de mini_batch arquivo. A run() função deve retornar um pandas DataFrame ou uma matriz. Cada elemento retornado indica uma execução bem-sucedida do elemento input no mini_batch. Para obter mais informações sobre como criar um script de pontuação, consulte Noções básicas sobre o script de pontuação.
   environment	O ambiente para pontuar o modelo. O exemplo define um ambiente embutido usando conda_file e image. As conda_file dependências são instaladas sobre o image. O ambiente é automaticamente registrado com um nome e uma versão gerados automaticamente. Consulte o Esquema de ambiente para obter mais opções. Como prática recomendada para cenários de produção, você deve criar o ambiente separadamente e consultá-lo aqui. Para fazer referência a um ambiente existente, use a azureml:<environment-name>:<environment-version> sintaxe.
   compute	O cálculo para executar a pontuação em lote. O exemplo usa o batch-cluster criado no início e faz referência a ele usando a azureml:<compute-name> sintaxe.
   resources.instance_count	O número de instâncias a serem usadas para cada trabalho de pontuação em lote.
   settings.max_concurrency_per_instance	O número máximo de execuções paralelas scoring_script por instância.
   settings.mini_batch_size	O número de arquivos que o scoring_script pode processar em uma run() chamada.
   settings.output_action	Como a saída deve ser organizada no arquivo de saída. append_row Mescla todos os run() resultados de saída retornados em um único arquivo chamado output_file_name. summary_only não mesclará os resultados de saída e calculará apenas error_threshold.
   settings.output_file_name	O nome do arquivo de saída de pontuação em lote para append_rowoutput_action.
   settings.retry_settings.max_retries	O número máximo de tentativas para um .scoring_scriptrun()
   settings.retry_settings.timeout	O tempo limite em segundos para marcar scoring_scriptrun() um mini lote.
   settings.error_threshold	O número de falhas de pontuação do arquivo de entrada que devem ser ignoradas. Se a contagem de erros para toda a entrada ultrapassar esse valor, o trabalho de pontuação em lote será encerrado. O exemplo usa -1, que indica que qualquer número de falhas é permitido sem encerrar o trabalho de pontuação em lote.
   settings.logging_level	Registre a verborragia. Os valores em verbosidade crescente são: WARNING, INFO e DEBUG.
   settings.environment_variables	Dicionário de pares nome-valor de variável de ambiente a serem definidos para cada trabalho de pontuação em lote.

9. Aceda à aba Endpoints no menu lateral.

   1. Selecione a guia Pontos de extremidade>em lote Criar.

   2. Dê um nome ao ponto final, neste caso mnist-batch. Você pode configurar o restante dos campos ou deixá-los em branco.

   3. Selecione Avançar para ir para a seção "Modelo".

   4. Selecione o modelo mnist-classifier-torch.

   5. Selecione Avançar para ir para a página "Implantação".

   6. Dê um nome à implantação.

10. Para a ação Output, certifique-se de que Acrescentar linha está selecionada.

    1. Para Nome do arquivo de saída, verifique se o arquivo de saída de pontuação em lote é o que você precisa. A predefinição é predictions.csv.

    2. Para o tamanho do mini lote, ajuste o tamanho dos arquivos que serão incluídos em cada minilote. Esse tamanho controla a quantidade de dados que seu script de pontuação recebe por lote.

    3. Para Tempo limite de pontuação (segundos), certifique-se de dar tempo suficiente para que sua implantação marque um determinado lote de arquivos. Se você aumentar o número de arquivos, geralmente terá que aumentar o valor de tempo limite também. Modelos mais caros (como os baseados em deep learning) podem exigir valores elevados neste campo.

    4. Para simultaneidade máxima por instância, configure o número de executores que você deseja ter para cada instância de computação obtida na implantação. Um número maior aqui garante um maior grau de paralelização, mas também aumenta a pressão de memória na instância de computação. Ajuste esse valor completamente com o tamanho do lote Mini.

    5. Uma vez feito, selecione Avançar para ir para a página "Código + ambiente".

    6. Para "Select a scoring script for inferencing", navegue para localizar e selecionar o arquivo de script de pontuação deployment-torch/code/batch_driver.py.

    7. Na seção "Selecionar ambiente", selecione o ambiente que você criou anteriormente torch-batch-env.

    8. Selecione Avançar para ir para a página "Computação".

    9. Selecione o cluster de computação criado em uma etapa anterior.

       Aviso

       Os clusters Kubernetes do Azure têm suporte em implantações em lote, mas somente quando criados usando a CLI do Azure Machine Learning ou o SDK do Python.

    10. Em Contagem de instâncias, insira o número de instâncias de computação que você deseja para a implantação. Neste caso, use 2.

    11. Selecione Seguinte.

11. Crie a implantação:

    • CLI do Azure
    • Píton
    • Estúdio

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

    az ml batch-deployment create --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default
    

    Gorjeta

    O --set-default parâmetro define a implantação recém-criada como a implantação padrão do ponto de extremidade. É uma maneira conveniente de criar uma nova implantação padrão do ponto de extremidade, especialmente para a primeira criação de implantação. Como prática recomendada para cenários de produção, convém criar uma nova implantação sem defini-la como padrão. Verifique se a implantação funciona como esperado e, em seguida, atualize a implantação padrão mais tarde. Para obter mais informações sobre como implementar esse processo, consulte a seção Implantar um novo modelo .

12. Verifique os detalhes do ponto de extremidade e da implantação do lote.

    • CLI do Azure
    • Píton
    • Estúdio

    Use show para verificar o ponto de extremidade e os detalhes da implantação. Para verificar uma implantação em lote, execute o seguinte código:

    DEPLOYMENT_NAME="mnist-torch-dpl"
    az ml batch-deployment show --name $DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME
    

13. Selecione o separador Pontos de extremidade em lote.

    1. Selecione o ponto de extremidade em lote que você deseja visualizar.

    2. A página Detalhes do ponto de extremidade mostra os detalhes do ponto de extremidade, juntamente com todas as implantações disponíveis no ponto de extremidade.

       

Executar pontos de extremidade em lote e acessar resultados

Compreender o fluxo de dados

Antes de executar o seu endpoint de lote, compreenda como os dados circulam no sistema.

Entradas: Dados a processar (pontuação). Isto inclui:

• Arquivos armazenados no Armazenamento do Azure (armazenamento de blob, data lake)
• Pastas com vários arquivos
• Conjuntos de dados registrados no Azure Machine Learning

Processamento: O modelo implantado processa os dados de entrada em lotes (minilotes) e gera previsões.

Saídas: resultados do modelo, armazenados como arquivos no Armazenamento do Azure. Por padrão, as saídas são salvas no armazenamento de blob padrão do espaço de trabalho, mas você pode especificar um local diferente.

Invocar um ponto de extremidade em lote

Invocar um ponto de extremidade em lote aciona um trabalho de pontuação em lote. O trabalho name é retornado na resposta de invocação e acompanha o progresso do processamento em lote. Especifique o caminho do ficheiro de dados de entrada para que os endpoints possam localizar os dados a serem avaliados. O exemplo a seguir mostra como iniciar um novo trabalho sobre um exemplo de dados do conjunto de dados MNIST armazenado em uma Conta de Armazenamento do Azure.

Você pode executar e invocar um ponto de extremidade em lote usando a CLI do Azure, o SDK do Azure Machine Learning ou pontos de extremidade REST. Para obter mais informações sobre essas opções, consulte Criar trabalhos e dados de entrada para pontos de extremidade em lote.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $SAMPLE_INPUT_URI --input-type uri_folder --query name -o tsv)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    input=Input(
        path=Path(temp_data_path) / "data",
        type=AssetTypes.URI_FOLDER,
    ),
)

Os pontos de extremidade em lote suportam a leitura de arquivos ou pastas localizados em locais diferentes. Para saber mais sobre os tipos suportados e como especificá-los, consulte Acessando dados de trabalhos de pontos de extremidade em lote.

Monitorar o progresso da execução do trabalho em lote

Os trabalhos de pontuação em lote levam tempo para processar todas as entradas.

az ml job show -n $JOB_NAME --web

ml_client.jobs.get(job.name)

Verifique os resultados da pontuação do lote

As saídas de trabalho são armazenadas no armazenamento em nuvem, seja no armazenamento de blob padrão do espaço de trabalho ou no armazenamento especificado. Para saber como alterar os padrões, consulte Configurar o local de saída. As etapas a seguir permitem que você exiba os resultados da pontuação no Gerenciador de Armazenamento do Azure quando o trabalho for concluído:

1. Execute o código a seguir para abrir o trabalho de pontuação em lote no estúdio do Azure Machine Learning. O link do estúdio de trabalho também está incluído na resposta de invoke, como o valor de interactionEndpoints.Studio.endpoint.

   az ml job show -n $JOB_NAME --web
   

2. No gráfico do trabalho, selecione a batchscoring etapa.

3. Selecione a guia Saídas + logs e, em seguida, selecione Mostrar saídas de dados.

4. Em Saídas de dados, selecione o ícone para abrir o Gerenciador de Armazenamento.

   

   Os resultados da pontuação no Storage Explorer são semelhantes à seguinte página de exemplo:

   

Configurar o local de saída

Por padrão, os resultados da pontuação em lote são armazenados no armazém blob padrão do espaço de trabalho em uma pasta nomeada pelo nome do trabalho (um GUID gerado pelo sistema). Configurar o local de saída ao invocar o endpoint do lote.

OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
OUTPUT_PATH="azureml://datastores/workspaceblobstore/paths/$ENDPOINT_NAME"

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $SAMPLE_INPUT_URI --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

batch_ds = ml_client.datastores.get_default()

filename = f"predictions-{random.randint(0,99999)}.csv"

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path=Path(temp_data_path) / "data",
        type=AssetTypes.URI_FOLDER,
    ),
    params_override=[
        {"output_dataset.datastore_id": f"azureml:{batch_ds.id}"},
        {"output_dataset.path": f"/{endpoint_name}/"},
        {"output_file_name": filename},
    ],
)

Substituir a configuração de implantação para cada tarefa

Ao invocar um endpoint em lote, pode alterar algumas definições para maximizar o uso eficaz dos recursos de computação e melhorar o desempenho. Esse recurso é útil quando você precisa de configurações diferentes para trabalhos diferentes sem modificar permanentemente a implantação.

Quais configurações podem ser substituídas?

Você pode definir as seguintes configurações por trabalho:

Como substituir configurações

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --mini-batch-size 20 --instance-count 5 --query name -o tsv)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(path="./data"),
    params_override=[{"mini_batch_size": "20"}, {"compute.instance_count": "5"}],
)

Adicionar implantações a um ponto de extremidade

Depois de ter um ponto de extremidade em lote com uma implantação, você pode continuar a refinar seu modelo e adicionar novas implantações. Os pontos de extremidade em lote continuarão atendendo à implantação padrão enquanto você desenvolve e implanta novos modelos sob o mesmo ponto de extremidade. As implantações não afetam umas às outras.

Neste exemplo, você adiciona uma segunda implantação que usa um modelo criado com Keras e TensorFlow para resolver o mesmo problema MNIST.

Adicionar uma segunda implantação

1. Crie um ambiente para sua implantação em lote. Inclua todas as dependências que seu código precisa executar. Adicione a biblioteca azureml-core, pois ela é necessária para implantações em lote. A definição de ambiente a seguir inclui as bibliotecas necessárias para executar um modelo com o TensorFlow.

   • CLI do Azure
   • Píton
   • Estúdio

   A definição de ambiente é incluída na própria definição de implantação como um ambiente anônimo.

   environment:
     name: batch-tensorflow-py38
     image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest
     conda_file: environment/conda.yaml
   

2. Copie o conteúdo do arquivo deployment-keras/environment/conda.yaml do repositório GitHub para o portal.

   1. Selecione Avançar até chegar à "Página de revisão".

   2. Selecione Criar e aguarde até que o ambiente esteja pronto para uso.

   ---

   O arquivo conda usado tem a seguinte aparência:

   deployment-keras/ambiente/conda.yaml

   name: tensorflow-env
   channels:
     - conda-forge
   dependencies:
     - python=3.8.5
     - pip
     - pip:
       - pandas
       - tensorflow
       - pillow
       - azureml-core
       - azureml-dataset-runtime[fuse]
   

3. Crie um script de pontuação para o modelo:

   deployment-keras/código/batch_driver.py

   import os
   import numpy as np
   import pandas as pd
   import tensorflow as tf
   from typing import List
   from os.path import basename
   from PIL import Image
   from tensorflow.keras.models import load_model
   
   
   def init():
       global model
   
       # AZUREML_MODEL_DIR is an environment variable created during deployment
       model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")
   
       # load the model
       model = load_model(model_path)
   
   
   def run(mini_batch: List[str]) -> pd.DataFrame:
       print(f"Executing run method over batch of {len(mini_batch)} files.")
   
       results = []
       for image_path in mini_batch:
           data = Image.open(image_path)
           data = np.array(data)
           data_batch = tf.expand_dims(data, axis=0)
   
           # perform inference
           pred = model.predict(data_batch)
   
           # Compute probabilities, classes and labels
           pred_prob = tf.math.reduce_max(tf.math.softmax(pred, axis=-1)).numpy()
           pred_class = tf.math.argmax(pred, axis=-1).numpy()
   
           results.append(
               {
                   "file": basename(image_path),
                   "class": pred_class[0],
                   "probability": pred_prob,
               }
           )
   
       return pd.DataFrame(results)
   

4. Criar uma definição de implantação

   • CLI do Azure
   • Píton
   • Estúdio

   deployment-keras/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
   name: mnist-keras-dpl
   description: A deployment using Keras with TensorFlow to solve the MNIST classification dataset.
   endpoint_name: mnist-batch
   type: model
   model: 
     name: mnist-classifier-keras
     path: model
   code_configuration:
     code: code
     scoring_script: batch_driver.py
   environment:
     name: batch-tensorflow-py38
     image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest
     conda_file: environment/conda.yaml
   compute: azureml:batch-cluster
   resources:
     instance_count: 1
   settings:
     max_concurrency_per_instance: 2
     mini_batch_size: 10
     output_action: append_row
     output_file_name: predictions.csv
   

5. Selecione Avançar para prosseguir para a página "Código + ambiente".

   1. Para Select a scoring script for inferencing, navegue para selecionar o arquivo de script de pontuação deployment-keras/code/batch_driver.py.

   2. Em Selecionar ambiente, selecione o ambiente criado em uma etapa anterior.

   3. Selecione Seguinte.

   4. Na página Computação, selecione o cluster de computação criado em uma etapa anterior.

   5. Em Contagem de instâncias, insira o número de instâncias de computação que você deseja para a implantação. Neste caso, use 2.

   6. Selecione Seguinte.

6. Crie a implantação:

   • CLI do Azure
   • Píton
   • Estúdio

   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 --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME
   

   Gorjeta

   O --set-default parâmetro está ausente neste caso. Como prática recomendada para cenários de produção, crie uma nova implantação sem defini-la como padrão. Em seguida, verifique-o e atualize a implantação padrão mais tarde.

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

Para testar a nova implantação não padrão, você precisa saber o nome da implantação que deseja executar.

DEPLOYMENT_NAME="mnist-keras-dpl"
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --deployment-name $DEPLOYMENT_NAME --input $SAMPLE_INPUT_URI --input-type uri_folder --query name -o tsv)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment_keras.name,
    input=Input(
        path=Path(temp_data_path) / "data",
        type=AssetTypes.URI_FOLDER,
    ),
)

Atualizar a implantação em lote padrão

Embora você possa invocar uma implantação específica dentro de um ponto de extremidade, normalmente desejará invocar o próprio ponto de extremidade e permitir que o ponto de extremidade decida qual implantação usar — a implantação padrão. Você pode alterar a implantação padrão (e, consequentemente, alterar o modelo que serve a implantação) sem alterar seu contrato com o usuário que invoca o ponto de extremidade. Use o código a seguir para atualizar a implantação padrão:

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_keras.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

Excluir o ponto de extremidade e a implantação em lote

az ml batch-deployment delete --name mnist-torch-dpl --endpoint-name $ENDPOINT_NAME --yes

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

ml_client.batch_deployments.begin_delete(
    endpoint_name=endpoint_name, name=deployment.name
).result()

ml_client.batch_endpoints.begin_delete(name=endpoint_name)

Conteúdos relacionados

• Aceder a dados dos trabalhos de endereços de dados em lote
• Autenticação em terminais em lote
• Isolamento da rede nos endpoints em batch
• Solução de problemas de endpoints em lote