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

Artigo
09/01/2024

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: Azure CLI ml extension v2 (atual)

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

Instale o SDK do Azure Machine Learning para Python.
```
pip install azure-ai-ml
```
Não há 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ó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

Para acompanhar este exemplo em um Jupyter Notebook, no repositório clonado, abra o bloco de anotações: mnist-batch.ipynb.

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>

A área de trabalho é o recurso de nível superior do Azure Machine Learning que proporciona um local centralizado para trabalhar com todos os artefactos que cria quando utiliza o Azure Machine Learning. Nesta seção, você se conecta ao espaço de trabalho 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

Nota

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

Configure os detalhes do espaço de trabalho e obtenha um identificador para o espaço de trabalho:

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

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()

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.

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"
```
Coloque o nome do ponto de extremidade em uma variável para que você possa facilmente consultá-lo mais tarde.
```
endpoint_name = "mnist-batch"
```
Você fornece o nome do ponto de extremidade mais tarde, no ponto em que cria a implantação.

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.

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 de ponto de extremidade em lote, consulte Classe BatchEndpoint.

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.

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
```
```
ml_client.begin_create_or_update(endpoint).result()
```
Você cria o ponto de extremidade mais tarde, no ponto 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 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

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"
```
```
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 Registrar de>arquivos locais.
3. No assistente, deixe a opção Tipo de modelo como Tipo não especificado.
4. Selecione Procurar>pasta> Selecione a pasta>deployment-torch/model Avançar.
5. Configure o nome do modelo: mnist-classifier-torch. Você pode deixar o resto dos campos como estão.
6. Selecione Registar.

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)

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
```
Obtenha uma referência ao 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 estes passos:
1. Navegue até a guia Ambientes no menu lateral.
2. Selecione a guia Ambientes>personalizados Criar.
3. Digite o nome do ambiente, neste caso torch-batch-env.
4. Em Select environment source, selecione Use existing docker image with optional conda file.
5. Em Caminho da imagem do Registro de contêiner, digite 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 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.

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`	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` 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`	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 máximo de tentativas para um .`scoring_script` `run()`
`settings.retry_settings.timeout`	O tempo limite em segundos para marcar `scoring_script` `run()` 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.

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 configurar as seguintes propriedades principais de uma implantação em lote:

Chave	Description
`name`	Nome da implantação.
`endpoint_name`	Nome do ponto de extremidade sob o 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 versionado existente no espaço de trabalho ou uma especificação de modelo embutido.
`environment`	O ambiente a ser usado para a implantação. Esse valor pode ser uma referência a um ambiente versionado existente no espaço de trabalho ou uma especificação de ambiente embutido (opcional para modelos MLflow).
`code_configuration`	A configuração sobre como executar a inferência para o modelo (opcional para modelos MLflow).
`code_configuration.code`	Caminho para o diretório do código-fonte para pontuar o 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 lote.
`instance_count`	O número de nós a serem usados para cada trabalho de pontuação em lote.
`settings`	A configuração de inferência de implantação do modelo.
`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 `code_configuration.scoring_script` pode processar em uma `run`() chamada.
`settings.retry_settings`	Repita as configurações para pontuar cada mini lote.
`settings.retry_settingsmax_retries`	O número máximo de tentativas para um mini lote com falha ou expirado (o padrão é 3).
`settings.retry_settingstimeout`	O tempo limite em segundos para marcar um mini lote (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`. A predefinição é `append_row`.
`settings.logging_level`	O nível de verbosidade do log. Os valores permitidos são `warning`, `info`, `debug`. A predefinição é `info`.
`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.

No estúdio, siga estes passos:

Navegue até a guia Pontos de extremidade no menu lateral.
Selecione a guia Pontos de extremidade>em lote Criar.
Dê um nome ao ponto final, 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.
Para a ação Saída, verifique se a opção Acrescentar linha está selecionada.
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.
Para o tamanho do mini lote, ajuste o tamanho dos arquivos que serão incluídos em cada minilote. Esse tamanho controlará a quantidade de dados que seu script de pontuação recebe por lote.
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.
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.
Uma vez feito, selecione Avançar para ir para a página "Código + ambiente".
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.
Na seção "Selecionar ambiente", selecione o ambiente que você criou anteriormente torch-batch-env.
Selecione Avançar para ir para a página "Computação".
Selecione o cluster de computação criado em uma etapa anterior.

Aviso

O cluster Kubernetes do Azure tem suporte em implantações em lote, mas somente quando criado usando a CLI do Azure Machine Learning ou o SDK do Python.
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.
Selecione Seguinte.

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 .
Usando o MLClient criado anteriormente, crie a implantação no espaço de trabalho. Este comando inicia a criação da implantação e retorna uma resposta de confirmação enquanto a criação da implantação continua.
```
ml_client.begin_create_or_update(deployment).result()
```
Quando a implantação for concluída, defina a nova implantação como a implantação 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.
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
```
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 de lote.
3. Selecione o ponto de extremidade em lote que você deseja visualizar.
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 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)

Gorjeta

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

Em geral, você pode usar um parâmetro de dicionário inputs = {} com o invoke método 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 input parâmetro como uma maneira mais curta de especificar o local dos 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 de lote.
Selecione o ponto de extremidade em lote que você acabou de criar.
Selecione Criar trabalho.
Em Implantação, selecione a implantação a ser executada.
Selecione Avançar para ir para a página "Selecionar fonte de dados".
Para o "Tipo de fonte de dados", selecione Datastore.
Para o "Datastore", selecione workspaceblobstore no menu suspenso.
Em "Caminho", insira o URL https://azuremlexampledata.blob.core.windows.net/data/mnist/samplecompleto.

Gorjeta

Esse caminho funciona somente porque o caminho fornecido tem acesso público habilitado. Em geral, você precisa registrar a fonte de dados como um armazenamento de dados. Consulte Acessando dados de trabalhos de pontos de extremidade em lote para obter detalhes.
Selecione Seguinte.
Selecione Criar para iniciar o trabalho.

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

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.

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:

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
```
No gráfico do trabalho, selecione a batchscoring etapa.
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 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 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)

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

batch_ds = ml_client.datastores.get_default()

Depois de 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ê 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)

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

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

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
```
Obtenha uma referência ao 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. Digite o nome do ambiente, neste caso keras-batch-env.
4. Em Select environment source, selecione Use existing docker image with optional conda file.
5. Em Caminho da imagem do Registro de contêiner, digite 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/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]
```

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)

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 de lote.
3. Selecione o ponto de extremidade de lote existente onde 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. Desfazer a seleção para a opção: Torne essa nova implantação o padrão para trabalhos em lote.
9. Para a ação Saída, verifique se a opção Acrescentar linha está selecionada.
10. 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.
11. Para o tamanho do mini lote, 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. 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.
13. 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.
14. Selecione Avançar para ir para a página "Código + ambiente".
15. Para Select a scoring script for inferencing, navegue para selecionar o arquivo de script de pontuação deployment-keras/code/batch_driver.py.
16. Em Selecionar ambiente, selecione o ambiente criado em uma etapa anterior.
17. Selecione Seguinte.
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 que você deseja para a implantação. Neste caso, use 2.
20. Selecione Seguinte.
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.
Usando o MLClient criado anteriormente, crie a implantação no espaço de trabalho. Este comando inicia a criação da implantação e retorna uma resposta de confirmação enquanto a criação da implantação continua.
```
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)

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.

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,
    ),
)

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

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

Se você não estiver usando 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 suas 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)

Acesso a dados de trabalhos de pontos de extremidade em lote.
Autenticação em pontos de extremidade de lote.
Isolamento de rede em pontos de extremidade em lote.
Solução de problemas de pontos de extremidade em lote.

Partilhar via

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

Pré-requisitos

Clone o repositório de exemplos

Prepare o seu sistema

Ligar à sua área de trabalho

Criar computação

Criar um ponto de extremidade em lote

Criar uma implantação em lote

Executar pontos de extremidade em lote e acessar resultados

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

Verifique os resultados da pontuação do lote

Configurar o local de saída

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

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

Partilhar via

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

Pré-requisitos

Clone o repositório de exemplos

Prepare o seu sistema

Ligar à sua área de trabalho

Criar computação

Criar um ponto de extremidade em lote

Criar uma implantação em lote

Executar pontos de extremidade em lote e acessar resultados

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

Verifique os resultados da pontuação do lote

Configurar o local de saída

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

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údos relacionados

Comentários

Recursos adicionais