Share via

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

  • Artigo

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

Os pontos de extremidade em lote fornecem uma maneira conveniente de implantar modelos que executam inferência em grandes volumes de dados. Esses endpoints simplificam o processo de hospedagem de seus modelos para pontuação em lote, de modo que seu foco esteja no aprendizado de máquina, e não na infraestrutura.

Use pontos de extremidade em lote para implantação de modelo quando:

  • Você tem modelos caros que exigem um tempo maior para executar a inferência.
  • Você precisa executar inferência sobre grandes quantidades de dados que são distribuídos em vários arquivos.
  • Você não tem requisitos de baixa latência.
  • Você pode tirar proveito da paralelização.

Neste artigo, você usa um ponto de extremidade 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). Em seguida, o modelo implantado executa a inferência em lote sobre grandes quantidades de dados — neste caso, arquivos de imagem. Você começa criando uma implantação em lote de um modelo que foi criado usando o Torch. Essa implantação se torna a padrão no ponto de extremidade. Mais tarde, você cria uma segunda implantação de um modo que foi criado com o TensorFlow (Keras), testa a segunda implantação e a define como a implantação padrão do ponto de extremidade.

Para acompanhar os exemplos de código e os arquivos necessários para executar os comandos neste artigo localmente, consulte a seção Clone the examples repository . Os exemplos de código e arquivos estão contidos no repositório azureml-examples .

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:

    APLICA-SE A:Extensão ml da CLI do Azure 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

Prepare o seu sistema

Ligar à sua área de trabalho

Primeiro, conecte-se ao espaço de trabalho do Azure Machine Learning onde você trabalhará.

Se você ainda não definiu os padrões para a CLI do Azure, salve suas configurações padrão. Para evitar passar os valores da sua assinatura, espaço de trabalho, grupo de recursos e local várias vezes, execute este código:

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. Você pode ajustar conforme necessário e fazer referência à sua computação usando azureml:<your-compute-name>o .

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

Nota

Você não será cobrado pela computação neste momento, pois o cluster permanece em 0 nós até que um ponto de extremidade em lote seja invocado e um trabalho de pontuação em lote seja enviado. Para obter mais informações sobre custos de computação, consulte Gerenciar e otimizar custos para AmlCompute.

Criar um ponto de extremidade em lote

Um ponto de extremidade em lote é um ponto de extremidade HTTPS que os clientes podem chamar para disparar um trabalho de pontuação em lote. Um trabalho de pontuação em lote é um trabalho que pontua várias entradas. Uma implantação em lote é um conjunto de recursos de computação que hospeda o modelo que faz a pontuação em lote real (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?.

Gorjeta

Uma das implantações em lote serve como a implantação padrão para o ponto de extremidade. Quando o ponto de extremidade é invocado, a implantação padrão faz a pontuação em lote real. Para obter mais informações sobre pontos de extremidade em lote e implantações, consulte pontos de extremidade em lote e implantação em lote.

  1. Nomeie o ponto de extremidade. O nome do ponto de extremidade deve ser exclusivo dentro de uma região do Azure, já que 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.

    Coloque o nome do ponto de extremidade em uma variável para que você possa facilmente consultá-lo mais tarde.

    ENDPOINT_NAME="mnist-batch"

  2. Configurar o ponto de extremidade em lote

    O seguinte arquivo YAML define um ponto de extremidade em lote. Você pode usar esse arquivo com o comando CLI para a criação de pontos finais 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 Description
    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:

    Execute o código a seguir para criar um ponto de extremidade 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 pré-criadas

  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.

    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 sua implantação em lote será 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:

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

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

    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.

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

    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-ubuntu20.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 Description
    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() será 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 serão instaladas sobre o image. O ambiente será automaticamente registrado com um nome e 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 [Opcional] O número máximo de execuções paralelas scoring_script por instância.
    settings.mini_batch_size [Opcional] O número de arquivos que o scoring_script pode processar em uma run() chamada.
    settings.output_action [Opcional] Como a saída deve ser organizada no arquivo de saída. append_row mesclará 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 [Opcional] O nome do arquivo de saída de pontuação em lote para append_rowoutput_action.
    settings.retry_settings.max_retries [Opcional] O número máximo de tentativas para um .scoring_scriptrun()
    settings.retry_settings.timeout [Opcional] O tempo limite em segundos para marcar scoring_scriptrun() um mini lote.
    settings.error_threshold [Opcional] 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 [Opcional] Registre a verborragia. Os valores em verbosidade crescente são: WARNING, INFO e DEBUG.
    settings.environment_variables [Opcional] Dicionário de pares nome-valor de variável de ambiente a serem definidos para cada trabalho de pontuação em lote.

  5. Crie a implantação:

    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 .

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

    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

Executar pontos de extremidade em lote e acessar resultados

Invocar um ponto de extremidade em lote aciona um trabalho de pontuação em lote. O trabalho name é retornado da resposta invoke e pode ser usado para acompanhar o progresso da pontuação em lote. Ao executar modelos para pontuação em pontos de extremidade em lote, você precisa especificar o caminho para os dados de entrada para que os pontos de extremidade possam encontrar os dados que você deseja pontuar. 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 detalhes sobre essas opções, consulte Criar trabalhos e dados de entrada para pontos de extremidade em lote.

Nota

Como funciona a paralelização?

As implantações em lote distribuem o trabalho no nível do arquivo, o que significa que uma pasta contendo 100 arquivos com minilotes de 10 arquivos gerará 10 lotes de 10 arquivos cada. Observe que isso acontece independentemente do tamanho dos arquivos envolvidos. Se os seus ficheiros forem demasiado grandes para serem processados em minilotes grandes, sugerimos que divida os ficheiros em ficheiros mais pequenos para obter um nível mais elevado de paralelismo ou diminua o número de ficheiros por minilote. Atualmente, as implantações em lote não podem levar em conta as distorções na distribuição de tamanho de um arquivo.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

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 geralmente levam algum tempo para processar todo o conjunto de entradas.

O código a seguir verifica o status do trabalho e gera um link para o estúdio do Azure Machine Learning para obter mais detalhes.

az ml job show -n $JOB_NAME --web

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.

    Captura de tela do estúdio mostrando a localização das saídas de dados de visualização.

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

    Captura de tela da saída de pontuação.

Configurar o local de saída

Por padrão, os resultados da pontuação em lote são armazenados no repositório de blob padrão do espaço de trabalho dentro de uma pasta nomeada pelo nome do trabalho (um GUID gerado pelo sistema). Você pode configurar onde armazenar as saídas de pontuação ao invocar o ponto de extremidade em lote.

Use output-path para configurar qualquer pasta em um armazenamento de dados registrado do Azure Machine Learning. A sintaxe do é a --output-path mesma de --input quando você está especificando uma pasta, ou seja, azureml://datastores/<datastore-name>/paths/<path-on-datastore>/. Use --set output_file_name=<your-file-name> para configurar um novo nome de arquivo de saída.

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 https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Aviso

Você deve usar um local de saída exclusivo. Se o arquivo de saída existir, o trabalho de pontuação em lote falhará.

Importante

Ao contrário das entradas, as saídas só podem ser armazenadas em armazenamentos de dados do Azure Machine Learning que são executados em contas de armazenamento de blob.

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

Quando você invoca um ponto de extremidade em lote, algumas configurações podem ser substituídas para fazer melhor uso dos recursos de computação e melhorar o desempenho. As seguintes configurações podem ser definidas por trabalho:

  • Contagem de instâncias: use essa configuração para substituir o número de instâncias a serem solicitadas do cluster de computação. Por exemplo, para um volume maior de entradas de dados, convém usar mais instâncias para acelerar a pontuação em lote de ponta a ponta.
  • Tamanho do minilote: use essa configuração para substituir o número de arquivos a serem incluídos em cada minilote. O número de minilotes é decidido pelo total de contagens de arquivos de entrada e pelo tamanho do minilote. Um tamanho de minilote menor gera mais minilotes. Os minilotes podem ser executados em paralelo, mas pode haver sobrecarga extra de agendamento e invocação.
  • Outras configurações, como tentativas máximas, tempo limite e limite de erro podem ser substituídas. Essas configurações podem afetar o tempo de pontuação em lote de ponta a ponta para diferentes cargas de trabalho.
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)

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 onde sua implantação em lote será executada. Inclua no ambiente qualquer dependência que seu código exija para ser executado. Você também precisa adicionar a biblioteca azureml-core, pois ela é necessária para que as implantações em lote funcionem. A definição de ambiente a seguir tem as bibliotecas necessárias para executar um modelo com o TensorFlow.

    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-ubuntu20.04:latest
  conda_file: environment/conda.yaml

    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]

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

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

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

  4. Crie 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 --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 https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

O aviso --deployment-name é usado para especificar a implantação a ser executada. Esse parâmetro permite que você faça invoke uma implantação não padrão sem atualizar a implantação padrão do ponto de extremidade em lote.

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

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

Se você não estiver usando a implantação em lote antiga, exclua-a executando o código a seguir. --yes é utilizado para confirmar a eliminação.

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

Execute o código a seguir para excluir o ponto de extremidade em lote e todas as suas implantações subjacentes. Os trabalhos de pontuação em lote não serão excluídos.

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

Conteúdos relacionados