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

Artigo
09/03/2024

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Os pontos de extremidade oferecem um modo conveniente de implantar modelos que executam a inferência em grandes volumes de dados. Esses pontos de extremidade simplificam o processo de hospedagem de seus modelos para pontuação em lote, de modo que você se concentre no aprendizado de máquina, em vez da infraestrutura.

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

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

Neste artigo, você usará um ponto de extremidade em lote para implantar um modelo de machine learning que resolve o problema de reconhecimento de dígito clássico do MNIST (Modified National Institute of Standards and Technology). Em seguida, o modelo implantado executa inferência em lotes em grandes quantidades de dados. Nesse 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. Posteriormente, você cria uma segunda implantação de um modo que foi criado com o TensorFlow (Keras), testa a segunda implantação e a defini 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 Clonar o repositório de exemplos. Os exemplos de código e os 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 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 Como gerenciar espaços de trabalho para criar um.
Para executar as seguintes tarefas, certifique-se de ter essas permissões no espaço de trabalho:
- Para criar/gerenciar pontos de extremidade e implantações em lotes: use as funções proprietário, colaborador ou uma função personalizada que permita Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Para criar implantações do ARM no grupo de recursos do espaço de trabalho: use as funções Proprietário, Colaborador ou uma função 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:
APLICA-SE A: Extensão de ML da CLI do Azurev2 (atual)

A CLI do Azure e a ml extensão do Azure Machine Learning.
```
az extension add -n ml
```
APLICA-SE A: SDK do Python azure-ai-ml v2 (atual)

Instalar o SDK do Azure Machine Learning para Python.
```
pip install azure-ai-ml
```
Não haverá mais requisitos se você planeja usar o Estúdio do Azure Machine Learning.

Clone o repositório de exemplos

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/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

Para acompanhar este exemplo em um Jupyter Notebook, no repositório clonado, abra o notebook: mnist-batch.ipynb.

Preparar seu sistema

Conectar-se ao workspace

Primeiro, conecte-se ao workspace do Azure Machine Learning no qual você trabalhará.

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

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

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, você se conecta ao workspace no qual executará tarefas de implantação.

Importe as bibliotecas necessárias:

from azure.ai.ml import MLClient, Input, load_component
from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
from azure.ai.ml.dsl import pipeline
from azure.identity import DefaultAzureCredential

Observação

As classes ModelBatchDeployment e PipelineComponentBatchDeployment foram introduzidas na versão 1.7.0 do SDK.

Configure os detalhes do workspace e obtenha um identificador para o workspace:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Criar computação

Os pontos de extremidade do 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 do Kubernetes. Os clusters são um recurso compartilhado, portanto, um cluster pode hospedar uma ou várias implantações em lote (juntamente com outras cargas de trabalho, se desejado).

Crie uma computação chamada batch-cluster, conforme mostrado no código a seguir. Você pode ajustar conforme necessário e fazer referência à sua computação usando o 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()

Observação

Você não será cobrado pela computação neste momento, já que o cluster permanecerá com 0 nós até que um ponto de extremidade de lote seja invocado e um trabalho de pontuação de lote seja enviado. Para obter mais informações sobre os custos de computação, consulte Gerenciar e otimizar o custo do 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 lotes. 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 hospedam o modelo que executa a pontuação em lote real (ou inferência em lote). Um ponto de extremidade em lote pode ter várias implantações em lote. Para obter mais informações sobre os pontos de extremidade em lote, confira O que são pontos de extremidade em lote.

Dica

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.

Nomeie o ponto de extremidade. O nome do ponto de extremidade deve ser exclusivo em 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 possamos referenciá-lo facilmente mais tarde.
```
ENDPOINT_NAME="mnist-batch"
```
Coloque o nome do ponto de extremidade em uma variável para que possamos referenciá-lo facilmente mais tarde.
```
endpoint_name = "mnist-batch"
```
Você fornece o nome do ponto de extremidade mais tarde, no momento em que cria a implantação.

Configurar o ponto de extremidade em lote

O arquivo YAML a seguir define um ponto de extremidade em lote. Você pode usar este arquivo com o comando da CLI para a criação de ponto de extremidade 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 o esquema YAML completo do ponto de extremidade em lote, consulte Esquema YAML do ponto de extremidade em lote da CLI (v2).

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

endpoint = BatchEndpoint(
    name=endpoint_name,
    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 mais informações sobre a definição do ponto de extremidade em lote, consulte Classe BatchEndpoint.

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

Criar 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
```
```
ml_client.begin_create_or_update(endpoint).result()
```
Você cria o ponto de extremidade mais tarde, no momento em que cria a implantação.

Criar uma implantação em lote

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

Um modelo registrado no workspace
O código para pontuar o modelo
Um ambiente com as dependências do modelo instaladas
A computação criada previamente e as configurações do recurso

Comece registrando o modelo a ser implantado—um modelo Torch para o popular problema de reconhecimento de dígito (MNIST). As Implantações em Lote só podem implantar modelos registrados no workspace. Você poderá pular essa etapa se o modelo que deseja implantar já estiver registrado.

Dica

Os modelos são associados à implantação em vez do ponto de extremidade. Isso significa que um só ponto de extremidade pode atender a modelos diferentes (ou versões de modelo) no mesmo ponto de extremidade, desde que os diferentes modelos (ou versões de modelo) sejam implantados em diferentes implantações.
```
MODEL_NAME='mnist-classifier-torch'
az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"
```
```
model_name = "mnist-classifier-torch"
model_local_path = "deployment-torch/model/"

model = ml_client.models.create_or_update(
    Model(
        name=model_name,
        path=model_local_path,
        type=AssetTypes.CUSTOM_MODEL,
        tags={"task": "classification", "framework": "torch"},
    )
)
```
1. Navegue até a guia Modelos no menu lateral.
2. Selecione Registro>De arquivos locais.
3. No assistente, deixe a opção Tipo de modelo como Tipo não especificado.
4. Selecione Procurar>Procurar pasta> Selecionar a pasta deployment-torch/model>Avançar.
5. Configure o nome do modelo: mnist-classifier-torch. Você pode deixar o restante dos campos como estão.
6. Selecione Registrar.

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

Observação

Para modelos MLflow, o Azure Machine Learning gera automaticamente o script de pontuação, ou seja, você não precisa fornecê-lo. Se o modelo for um modelo do MLflow, você poderá ignorar esta etapa. Para saber mais sobre como os pontos de extremidade em lote funcionam com modelos do MLflow, confira o artigo Usando modelos do MLflow em implantações em lote.

Aviso

Se você estiver implantando um modelo de AutoML (machine learning automatizado) automatizado em um ponto de extremidade em lote, observe que o script de pontuação que o AutoML fornece funciona somente 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 lotes.

deployment-torch/code/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)

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

deployment-torch/environment/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 maneira:
A definição de ambiente será incluída na própria definição de implantação como um ambiente anônimo. Você exibirá 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
```
Obtenha uma referência para o ambiente:
```
env = Environment(
    name="batch-torch-py38",
    conda_file="deployment-torch/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
```
No Estúdio do Azure Machine Learning, siga estas etapas:
1. Navegue até a guia Ambientes no menu lateral.
2. Selecione a guia Ambientes personalizados>Criar.
3. Insira o nome do ambiente, neste caso, torch-batch-env.
4. Para Selecionar origem do ambiente, selecione Usar imagem do docker existente com arquivo conda opcional.
5. Para Caminho da imagem de registro do contêiner, insira mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
6. Selecione Avançar para ir para a seção "Personalizar".
7. Copie o conteúdo do arquivo deployment-torch/environment/conda.yaml do repositório GitHub para o portal.
8. Selecione Avançar até chegar à "Página de revisão".
9. Selecione Criar e aguarde até que o ambiente esteja pronto para uso.
Aviso

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

Criar uma definição de implantação

deployment-torch/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 o esquema YAML completo da implantação em lote, consulte Esquema YAML da implantação em lote da CLI (v2).

Chave	Descrição
`name`	O nome da implantação.
`endpoint_name`	O nome do ponto de extremidade no qual criar a implantação.
`model`	O modelo a ser usado para a pontuação em lote. O exemplo define um modelo embutido usando `path`. Esta definição permite que os arquivos de modelo sejam carregados e registrados automaticamente com um nome e uma versão gerados automaticamente. Confira o Esquema do modelo para obter mais opções. Como prática recomendada para cenários de produção, você deve criar o modelo separadamente e fazer referência a ele aqui. Para referenciar um modelo existente, use a sintaxe `azureml:<model-name>:<model-version>`.
`code_configuration.code`	O diretório local que contém todo o código-fonte do Python usado para pontuar o modelo.
`code_configuration.scoring_script`	O arquivo Python no diretório `code_configuration.code`. Esse arquivo precisa ter uma função `init()` e uma função `run()`. Use a função `init()` para qualquer preparação cara 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 `mini_batch` é uma lista de caminhos de arquivo. A função `run()` deve retornar um DataFrame do Pandas ou uma matriz. Cada elemento retornado indica uma execução bem-sucedida de um elemento de entrada no `mini_batch`. Para obter mais informações sobre como criar um script de pontuação, confira Noções básicas sobre o script de pontuação.
`environment`	O ambiente para pontuar o modelo. O exemplo define um ambiente em linha usando `conda_file` e `image`. As dependências de `conda_file` serão instaladas na parte superior de `image`. O ambiente será registrado automaticamente com um nome e uma versão gerados automaticamente. Confira o Esquema do ambiente para obter mais opções. Como prática recomendada para cenários de produção, você deve criar o ambiente separadamente e fazer referência a ele aqui. Para referenciar um ambiente existente, use a sintaxe `azureml:<environment-name>:<environment-version>`.
`compute`	A computação 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 sintaxe `azureml:<compute-name>`.
`resources.instance_count`	O número de instâncias a serem usadas para cada trabalho de pontuação em lotes.
`settings.max_concurrency_per_instance`	O número máximo de execuções de `scoring_script` paralelas por instância.
`settings.mini_batch_size`	O número de arquivos que o `scoring_script` pode processar em uma chamada `run()`.
`settings.output_action`	Como a saída deve ser organizada no arquivo de saída. `append_row` irá mesclar todos os resultados de saída retornados `run()` em um único arquivo chamado `output_file_name`. `summary_only` não irá mesclar os resultados da 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_row` `output_action`.
`settings.retry_settings.max_retries`	O número de tentativas máximas para uma falha `scoring_script` `run()`.
`settings.retry_settings.timeout`	O tempo limite em segundos para um `scoring_script` `run()` para pontuar um mini lote.
`settings.error_threshold`	O número de falhas na pontuação do arquivo de entrada que devem ser ignoradas. Se a contagem de erros de toda a entrada ficar acima desse valor, o trabalho de pontuação em lote será terminado. 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`	Detalhamento do log. Os valores no detalhamento crescente são: WARNING, INFO e DEBUG.
`settings.environment_variables`	Dicionário de pares nome-valor da variável de ambiente a definir para cada trabalho de pontuação em lotes.

deployment = ModelBatchDeployment(
    name="mnist-torch-dpl",
    description="A deployment using Torch to solve the MNIST classification dataset.",
    endpoint_name=endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(
        code="deployment-torch/code/", scoring_script="batch_driver.py"
    ),
    environment=env,
    compute=compute_name,
    settings=ModelBatchDeploymentSettings(
        max_concurrency_per_instance=2,
        mini_batch_size=10,
        instance_count=2,
        output_action=BatchDeploymentOutputAction.APPEND_ROW,
        output_file_name="predictions.csv",
        retry_settings=BatchRetrySettings(max_retries=3, timeout=30),
        logging_level="info",
    ),
)

A classe BatchDeployment permite que você configure as seguintes propriedades principais de uma implantação em lote:

Chave	Descrição
`name`	Nome da implantação.
`endpoint_name`	O nome do ponto de extremidade no qual criar a implantação.
`model`	O modelo a ser usado para a implantação. Esse valor pode ser uma referência a um modelo com versão existente no workspace ou uma especificação de modelo embutida.
`environment`	O ambiente a ser usado para a implantação. Esse valor pode ser uma referência para um ambiente com versão existente no espaço de trabalho ou uma especificação de ambiente embutido (opcional para modelos do MLflow).
`code_configuration`	A configuração sobre como executar a inferência para o modelo (opcional para modelos do MLflow).
`code_configuration.code`	O caminho para o diretório do código-fonte de pontuação do modelo.
`code_configuration.scoring_script`	Caminho relativo para o arquivo de pontuação no diretório do código-fonte.
`compute`	Nome do destino de computação no qual executar os trabalhos de pontuação em lotes.
`instance_count`	O número de nós a ser usado para cada trabalho de pontuação em lotes.
`settings`	A configuração de inferência de implantação de modelo.
`settings.max_concurrency_per_instance`	O número máximo de execuções de `scoring_script` paralelas por instância.
`settings.mini_batch_size`	O número de arquivos que o `code_configuration.scoring_script` pode processar em uma chamada `run`().
`settings.retry_settings`	Tente novamente as configurações para pontuar cada mini lote.
`settings.retry_settingsmax_retries`	O número máximo de tentativas para um minilote com falha ou tempo limite (o padrão é 3).
`settings.retry_settingstimeout`	O tempo limite em segundos para pontuar um minilote (o padrão é 30).
`settings.output_action`	Como a saída deve ser organizada no arquivo de saída. Os valores permitidos são: `append_row` ou `summary_only`. O padrão é `append_row`.
`settings.logging_level`	O nível de detalhes do log. Os valores permitidos são `warning`, `info` e `debug`. O padrão é `info`.
`settings.environment_variables`	Dicionário de pares nome-valor da variável de ambiente a definir para cada trabalho de pontuação em lotes.

No estúdio, siga estas etapas:

Navegue até a guia Pontos de extremidade no menu lateral.
Selecione a guia Pontos de extremidade do Lote>Criar.
Dê um nome ao ponto de extremidade, neste caso, mnist-batch. Você pode configurar o restante dos campos ou deixá-los em branco.
Selecione Avançar para ir para a seção "Modelo".
Selecione o modelo mnist-classifier-torch.
Selecione Avançar para ir para a página "Implantação".
Dê um nome à implantação.
Em Ação de saída, verifique se a opção Acrescentar linha está selecionada.
Em Nome do arquivo de saída, verifique se o arquivo de saída de pontuação em lote é o que você precisa. O padrão é predictions.csv.
Em Tamanho do minilote, ajuste o tamanho dos arquivos que serão incluídos em cada minilote. O tamanho controlará a quantidade de dados que seu script de pontuação recebe por lote.
Em Tempo limite de pontuação (segundos), verifique se você está dando tempo suficiente para sua implantação pontuar determinado lote de arquivos. Se você aumentar o número de arquivos, geralmente também precisará aumentar o valor do tempo limite. Modelos mais caros (como aqueles baseados em aprendizado profundo), podem exigir valores altos nesse campo.
Em Simultaneidade máxima por instância, configure o número de executores que você deseja ter para cada instância de computação que você obtém na implantação. Um número mais alto 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 Tamanho do minilote.
Depois de terminar, selecione Avançar para ir para a página "Código + ambiente".
Em "Selecionar um script de pontuação para inferência", navegue para localizar e selecionar o arquivo de script de pontuação deployment-torch/code/batch_driver.py.
Na seção "Selecionar ambiente", selecione o ambiente criado anteriormente torch-batch-env.
Selecione Avançar para ir até a guia "Computação".
Selecione o cluster de computação criado em uma etapa anterior.

Aviso

Há suporte para o cluster do Kubernetes do Azure nas implantações em lote, mas somente quando criado por meio da CLI do Azure Machine Learning ou do SDK do Python.
Em Contagem de instâncias, insira o número de instâncias de computação desejadas para a implantação. Nesse caso, use 2.
Selecione Avançar.

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 --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default
```
Dica

O parâmetro --set-default 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 da implantação. Como prática recomendada para cenários de produção, talvez você queira criar uma nova implantação sem defini-la como padrão. Verifique se a implantação funciona conforme o esperado e atualize a implantação padrão mais tarde. Para obter mais informações sobre a implementação deste processo, consulte a seção Implantar um novo modelo.
Usando o MLClient criado anteriormente, crie a implantação no espaço de trabalho. Esse comando iniciará a criação da implantação e retornará uma resposta de confirmação enquanto a criação da implantação continuar.
```
ml_client.begin_create_or_update(deployment).result()
```
Depois que a implantação for concluída, defina a nova implantação como padrão no ponto de extremidade:
```
endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
No assistente, selecione Criar para iniciar o processo de implantação.
Verificar detalhes de implantação e ponto de extremidade do lote.
Use show para verificar detalhes de implantação e ponto de extremidade. 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
```
Para verificar uma implantação em lote, execute o seguinte código:
```
ml_client.batch_deployments.get(name=deployment.name, endpoint_name=endpoint.name)
```
Depois de criar o ponto de extremidade em lote, a página de detalhes do ponto de extremidade é aberta. Você também pode encontrar esta página seguindo estas etapas:
1. Navegue até a guia Pontos de extremidade no menu lateral.
2. Selecione a guia Pontos de extremidade do Lote.
3. Selecione o ponto de extremidade em lote que você deseja exibir.
4. 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 resultados de acesso

A invocação de um ponto de extremidade em lote dispara um trabalho de pontuação em lotes. O trabalho name é retornado da resposta da invocação e poderá ser usado para acompanhar o andamento da pontuação em lote. Ao executar modelos de 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 uma amostra de dados do conjunto de dados do MNIST armazenados em uma Conta de Armazenamento do Microsoft 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 lotes.

Observação

Como funciona a paralelização?

As implantações em lote distribuem o trabalho no nível do arquivo, o que significa que uma pasta que contém 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 arquivos forem grandes demais para serem processados em minilotes grandes, sugerimos que você divida os arquivos em arquivos menores para obter um nível mais alto de paralelismo ou diminuir o número de arquivos por minilote. Atualmente, as implantações em lote não podem considerar 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)

Dica

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

Em geral, você pode usar um parâmetro inputs = {} de dicionário com o método invoke para fornecer um número arbitrário de entradas necessárias para um ponto de extremidade em lote que contém uma implantação de modelo ou uma implantação de pipeline.

Para uma implantação de modelo, você pode usar o parâmetro input como uma maneira mais curta de especificar o local de dados de entrada para a implantação. Essa abordagem funciona porque uma implantação de modelo sempre usa apenas uma entrada de dados.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
)

Navegue até a guia Pontos de extremidade no menu lateral.
Selecione a guia Pontos de extremidade do Lote.
Selecione o ponto de extremidade de streaming que você acabou de criar.
Selecione Criar trabalho.
Em Implantação, selecione a implantação a ser executada.
Selecione Próximo para acessar a página "Selecionar fonte de dados".
Em "Tipo de fonte de dados", selecione Armazenamento de Dados.
Em "Armazenamento de Dados", selecione workspaceblobstore no menu suspenso.
Em "Caminho", insira a URL https://azuremlexampledata.blob.core.windows.net/data/mnist/sample completa.

Dica

Esse caminho funciona apenas porque o caminho fornecido tem acesso público habilitado. Em geral, você precisa registrar a fonte de dados como um Armazenamento de dados. Confira Como acessar dados de trabalhos de pontos de extremidade em lote para detalhes.
Selecione Avançar.
Selecione Criar para iniciar o trabalho.

Os pontos de extremidade de lote dão suporte para a leitura de arquivos ou pastas localizados em diferentes locais. Para saber mais sobre os tipos com suporte e como especificá-los, confira Como acessar dados a partir de trabalhos de ponto de extremidade em lotes.

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

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 mostrar mais detalhes.

az ml job show -n $JOB_NAME --web

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

ml_client.jobs.get(job.name)

Verificar os resultados da pontuação em lote

As saídas do trabalho são armazenadas no armazenamento em nuvem, seja no armazenamento padrão de blobs do espaço de trabalho, ou no armazenamento especificado por você. 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 Microsoft Azure quando o trabalho for concluído:

Execute o código a seguir para abrir o trabalho de pontuação em lotes no Estúdio do Azure Machine Learning. O link do estúdio do 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
```
No grafo do trabalho, selecione a etapa batchscoring.
Selecione a guia Saídas + logs e, em seguida, selecione Mostrar saídas de dados.
Em Saídas de dados, selecione o ícone para abrir Gerenciador de Armazenamento.

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

Configurar a localização de saída

Por padrão, os resultados da pontuação em lote são armazenados no armazenamento de blobs padrão do workspace dentro de uma pasta nomeada por nome do trabalho (um GUID gerado pelo sistema). Você poderá configurar o local em que as saídas de pontuação serão armazenadas ao invocar o ponto de extremidade em lote.

Use output-path para configurar qualquer pasta em um conjunto de dados registrado do Azure Machine Learning. A sintaxe para a --output-path é a mesma --input ao especificar 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)

Use params_override para configurar qualquer pasta em um armazenamento de dados registrado do Azure Machine Learning. Somente os armazenamentos de dados registrados têm suporte como caminhos de saída. Neste exemplo, você usa o armazenamento de dados padrão:

batch_ds = ml_client.datastores.get_default()

Quando identificar o armazenamento de dados que deseja usar, configure a saída da seguinte maneira:

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

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        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},
    ],
)

Aviso

Você precisa usar uma localização de saída exclusiva. 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 executados em contas de armazenamento de blobs.

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

Quando você invoca um ponto de extremidade em lote, algumas configurações podem ser substituídas para fazer o 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, talvez você queira usar mais instâncias para acelerar a pontuação em lote de ponta a ponta.
Tamanho do minilote: use esta 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 arquivo de entrada e tamanho do minilote. Um minilote menor gera mais minilotes. Mini lotes 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)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/"
    ),
    params_override=[{"mini_batch_size": "20"}, {"compute.instance_count": "5"}],
)

Adicionar implantações a um ponto de extremidade

Quando você tiver um ponto de extremidade em lote com uma implantação, poderá continuar refinando seu modelo e adicionando novas implantações. Os pontos de extremidade do lote continuarão atendendo à implantação padrão enquanto você desenvolve e implanta novos modelos no mesmo ponto de extremidade. As implantações não afetam uma à outra.

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

Adicionar uma segunda implantação

Crie um ambiente em que a implantação em lote será executada. Inclua no ambiente qualquer dependência que seu código exija para execução. 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
```
Obtenha uma referência para o ambiente:
```
env = Environment(
    name="batch-tensorflow-py38",
    conda_file="deployment-keras/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
```
1. Navegue até a guia Ambientes no menu lateral.
2. Selecione a guia Ambientes personalizados>Criar.
3. Insira o nome do ambiente, neste caso, keras-batch-env.
4. Para Selecionar origem do ambiente, selecione Usar imagem do docker existente com arquivo conda opcional.
5. Para Caminho da imagem de registro do contêiner, insira mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
6. Selecione Avançar para ir para a seção "Personalizar".
7. Copie o conteúdo do arquivo deployment-keras/environment/conda.yaml do repositório GitHub para o portal.
8. Selecione Avançar até chegar à "Página de revisão".
9. Selecione Criar e aguarde até que o ambiente esteja pronto para uso.
O arquivo Conda usado tem a seguinte aparência:

deployment-keras/environment/conda.yaml
```
name: tensorflow-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - pandas
    - tensorflow
    - pillow
    - azureml-core
    - azureml-dataset-runtime[fuse]
```

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

deployment-keras/code/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)

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
```
```
deployment_keras = ModelBatchDeployment(
    name="mnist-keras-dpl",
    description="A deployment using Keras to solve the MNIST classification dataset.",
    endpoint_name=endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(
        code="deployment-keras/code/", scoring_script="batch_driver.py"
    ),
    environment=env,
    compute=compute_name,
    settings=ModelBatchDeploymentSettings(
        instance_count=2,
        max_concurrency_per_instance=2,
        mini_batch_size=10,
        output_action=BatchDeploymentOutputAction.APPEND_ROW,
        output_file_name="predictions.csv",
        retry_settings=BatchRetrySettings(max_retries=3, timeout=30),
        logging_level="info",
    ),
)
```
1. Navegue até a guia Pontos de extremidade no menu lateral.
2. Selecione a guia Pontos de extremidade do Lote.
3. Selecione o ponto de extremidade em lote existente no qual você deseja adicionar a implantação.
4. Selecione Adicionar implantação.
5. Selecione Avançar para ir para a página "Modelo".
6. Na lista de modelos, selecione o modelo mnist e selecione Avançar.
7. Na página de configuração de implantação, dê um nome à implantação.
8. Desfaça a seleção da opção: Torne essa nova implantação o padrão para trabalhos em lotes.
9. Em Ação de saída, verifique se a opção Acrescentar linha está selecionada.
10. Em Nome do arquivo de saída, verifique se o arquivo de saída de pontuação em lote é o que você precisa. O padrão é predictions.csv.
11. Em Tamanho do minilote, ajuste o tamanho dos arquivos que serão incluídos em cada minilote. Isso controlará a quantidade de dados que seu script de pontuação recebe para cada lote.
12. Em Tempo limite de pontuação (segundos), verifique se você está dando tempo suficiente para sua implantação pontuar determinado lote de arquivos. Se você aumentar o número de arquivos, geralmente também precisará aumentar o valor do tempo limite. Modelos mais caros (como aqueles baseados em aprendizado profundo), podem exigir valores altos nesse campo.
13. Em Simultaneidade máxima por instância, configure o número de executores que você deseja ter para cada instância de computação que você obtém na implantação. Um número mais alto 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 Tamanho do minilote.
14. Selecione Avançar para ir para a página "Código + ambiente".
15. Em Selecionar um script de pontuação para inferência, navegue para selecionar o arquivo de script de pontuação deployment-keras/code/batch_driver.py.
16. Em Selecionar ambiente, selecione o ambiente que você criou em uma etapa anterior.
17. Selecione Avançar.
18. Na página Computação, selecione o cluster de computação criado em uma etapa anterior.
19. Em Contagem de instâncias, insira o número de instâncias de computação desejadas para a implantação. Nesse caso, use 2.
20. Selecione Avançar.
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 --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME
```
Dica

O parâmetro --set-default está ausente nesse 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 e atualize a implantação padrão mais tarde.
Usando o MLClient criado anteriormente, crie a implantação no espaço de trabalho. Esse comando iniciará a criação da implantação e retornará uma resposta de confirmação enquanto a criação da implantação continuar.
```
ml_client.begin_create_or_update(deployment_keras).result()
```
No assistente, selecione Criar para iniciar o processo de implantação.

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)

Observe que --deployment-name é usado para especificar a implantação para execução. Esse parâmetro permite invoke uma implantação não padrão sem atualizar a implantação padrão do ponto de extremidade em lote.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment_keras.name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
)

Observe que deployment_name é usado para especificar a implantação para execução. Esse parâmetro permite 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, geralmente desejará invocar o ponto de extremidade em si 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 atende à implantação) sem alterar seu contrato com o usuário invocando o ponto de extremidade. Use o seguinte código 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 em lote e a implantação

Se você não usar a implantação em lote antiga, exclua-a executando o código a seguir. --yes é usado para confirmar a exclusã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 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

Se você não usar a implantação em lote antiga, exclua-a executando o código a seguir.

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

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

ml_client.batch_endpoints.begin_delete(name=endpoint_name)

Compartilhar via

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

Pré-requisitos

Clone o repositório de exemplos

Preparar seu sistema

Conectar-se ao workspace

Criar computação

Criar um ponto de extremidade em lote

Criar uma implantação em lote

Executar pontos de extremidade em lote e resultados de acesso

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

Verificar os resultados da pontuação em lote

Configurar a localização de saída

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

Adicionar implantações a um ponto de extremidade

Adicionar uma segunda implantação

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

Atualizar a implantação em lote padrão

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

Comentários

Recursos adicionais

Compartilhar via

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

Pré-requisitos

Clone o repositório de exemplos

Preparar seu sistema

Conectar-se ao workspace

Criar computação

Criar um ponto de extremidade em lote

Criar uma implantação em lote

Executar pontos de extremidade em lote e resultados de acesso

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

Verificar os resultados da pontuação em lote

Configurar a localização de saída

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

Adicionar implantações a um ponto de extremidade

Adicionar uma segunda implantação

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

Atualizar a implantação em lote padrão

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

Conteúdo relacionado

Comentários

Recursos adicionais