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

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

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

Use pontos de extremidade em lotes para implantar modelos quando:

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

Este artigo mostra como usar um endpoint de lote para implantar um modelo de aprendizado de máquina que resolve o problema clássico de reconhecimento de dígitos do MNIST (Instituto Nacional de Padrões e Tecnologia Modificado). O modelo implantado executa inferência em lotes em grandes quantidades de dados, como arquivos de imagem. O processo começa com a criação de uma implantação em lote de um modelo criado usando o Torch. Essa implantação se torna a padrão no ponto de extremidade. Posteriormente, crie uma segunda implantação de um modelo criado com o TensorFlow (Keras), teste a segunda implantação e defina-a como a implantação padrão do ponto de extremidade.

Pré-requisitos

Antes de seguir as etapas neste artigo, verifique se você tem os seguintes pré-requisitos:

Uma 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 seguinte software 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 mlextensão do Azure Machine Learning.
```
az extension add -n ml
```
APLICA-SE A: SDK 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

Conecte-se ao seu 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 inserir os valores para sua assinatura, workspace, 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 do Azure Machine Learning, fornecendo um local centralizado para gerenciar todos os artefatos criados ao usar o Azure Machine Learning. Nesta seção, você se conecta ao workspace no qual executa 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
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. Ajuste conforme necessário e referencie sua computação usando azureml:<your-compute-name>.

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

compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="CPU cluster compute",
        min_instances=0,
        max_instances=2,
    )
    ml_client.compute.begin_create_or_update(compute_cluster).result()

Observação

Você não será cobrado pela computação neste momento, já que o cluster permanecerá com zero 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 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 lote. Um trabalho de pontuação em lote processa 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 (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 pontos de extremidade em lotes, consulte 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 for invocado, a implantação padrão executará a pontuação em lote. Para obter mais informações sobre pontos de extremidade e implantações em lotes, 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 porque o nome está incluído no URI do ponto de extremidade. Por exemplo, pode haver apenas um ponto de extremidade em lote com o nome mybatchendpoint em westus2.
Coloque o nome do ponto de extremidade em uma variável para 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. Use esse 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 obter o esquema YAML completo do ponto de extremidade em lote, consulte o 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 este código para criar um endpoint batch.
```
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 único ponto de extremidade pode atender a diferentes modelos (ou versões de modelos) sob o mesmo ponto de extremidade, desde que os diferentes modelos (ou versões de modelo) estejam implantados em implantações distintas.
```
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) 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 é 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-ubuntu22.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-ubuntu22.04:latest",
)
```
No Estúdio do Azure Machine Learning, siga estas etapas:
Vá para a guia Ambientes no menu lateral.
Selecione Ambientes personalizados>Criar.
1. Insira o nome do ambiente, neste caso, torch-batch-env.
2. Para Selecionar origem do ambiente, selecione Usar imagem do docker existente com arquivo conda opcional.
3. Para Caminho da imagem de registro do contêiner, insira mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
4. Selecione Avançar para ir para a seção "Personalizar".
5. Copie o conteúdo do arquivo deployment-torch/environment/conda.yaml do repositório GitHub para o portal.
Selecione Avançar até chegar à "página De revisão".
Selecione Criar e aguarde até que o ambiente esteja pronto.

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-ubuntu22.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 30
  error_threshold: -1
  logging_level: info

A tabela a seguir descreve as principais propriedades da implantação em lote. Para 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 `conda_file` são instaladas na parte superior do `image`. O ambiente é 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` 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_rowoutput_action`.
`settings.retry_settings.max_retries`	O número de tentativas máximas para uma falha `scoring_scriptrun()`.
`settings.retry_settings.timeout`	O tempo limite em segundos para um `scoring_scriptrun()` 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á 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`	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.

Vá para a aba Endpoints no menu lateral.
1. Selecione a guia Pontos de extremidade do Lote>Criar.
2. Dê um nome ao ponto de extremidade, neste caso, mnist-batch. Você pode configurar o restante dos campos ou deixá-los em branco.
3. Selecione Avançar para ir para a seção "Modelo".
4. Selecione o modelo mnist-classifier-torch.
5. Selecione Avançar para ir para a página "Implantação".
6. Dê um nome à implantação.
Para ação de Saída, verifique se Adicionar linha está selecionada.
1. 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.
2. Em Tamanho do minilote, ajuste o tamanho dos arquivos que serão incluídos em cada minilote. O tamanho controla a quantidade de dados que seu script de pontuação recebe por lote.
3. 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.
4. 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.
5. Depois de terminar, selecione Avançar para ir para a página "Código + ambiente".
6. 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.
7. Na seção "Selecionar ambiente", selecione o ambiente criado anteriormente torch-batch-env.
8. Selecione Avançar para ir até a guia "Computação".
9. 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.
10. Em Contagem de instâncias, insira o número de instâncias de computação desejadas para a implantação. Nesse caso, use 2.
11. 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.
Selecione a guia Pontos de extremidade em lote.
1. Selecione o ponto de extremidade em lote que você deseja exibir.
2. A página Detalhes do ponto de extremidade mostra os detalhes do ponto de extremidade, juntamente com todas as implantações disponíveis no ponto de extremidade.

Executar pontos de extremidade em lote e resultados de acesso

Noções básicas sobre o fluxo de dados

Antes de executar o endpoint de processamento em lote, entenda como os dados fluem pelo sistema:

Entradas: dados a serem processados (pontuação). Isso inclui:

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

Processamento: o modelo implantado processa os dados de entrada em lotes (mini-lotes) e gera previsões.

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

Invocar um ponto de extremidade em lote

A invocação de um ponto de extremidade em lote dispara um trabalho de pontuação em lotes. O trabalho name é retornado na resposta de invocação e acompanha o progresso da pontuação do lote. Especifique o caminho de dados de entrada para que os endpoints possam localizar os dados para avaliar. O exemplo a seguir mostra como iniciar um novo trabalho usando um conjunto de dados de amostra do 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, confira Criar trabalhos e dados de entrada para pontos de extremidade em lote.

Observação

Como funciona a paralelização?

As implantações em lote distribuem o trabalho no nível do arquivo. Por exemplo, uma pasta com 100 arquivos e mini-lotes de 10 arquivos gera 10 lotes de 10 arquivos cada. Isso acontece independentemente do tamanho do arquivo. Se os arquivos forem muito grandes para processamento em minilotes, divida-os em arquivos menores para aumentar o paralelismo ou reduzir o número de arquivos por mini-lote. As implantações em lote atualmente não são responsáveis por distorções na distribuição de tamanho do arquivo.

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

Dica

Qual é a diferença entre o os parâmetros inputs e 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 a localização 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=Path(temp_data_path) / "data",
        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

Trabalhos de pontuação em lote levam tempo para processar todas as 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 repositório de blobs padrão do workspace, em uma pasta nomeada com base no trabalho (um GUID gerado pelo sistema). Configure o destino de saída 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 $SAMPLE_INPUT_URI --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

O parâmetro params_override permite que você modifique as configurações de implantação para um trabalho específico sem alterar permanentemente a configuração de implantação. Isso é útil para ajustar configurações como o local de saída, o tamanho do minilote ou a contagem de instâncias para trabalhos individuais.

Os valores de parâmetro params_override correspondem às configurações de implantação que podem ser temporariamente modificadas para trabalhos individuais. Esses parâmetros vêm das configurações de esquema YAML da implantação, das configurações do armazenamento de dados (como caminhos de saída) e das variáveis de runtime que você define em seu código.

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=Path(temp_data_path) / "data",
        type=AssetTypes.URI_FOLDER,
    ),
    params_override=[
        {"output_dataset.datastore_id": f"azureml:{batch_ds.id}"},
        {"output_dataset.path": f"/{endpoint_name}/"},
        {"output_file_name": filename},
    ],
)

Dica

Use params_override quando precisar de configurações diferentes para trabalhos diferentes sem modificar sua implantação. Isso é especialmente útil para lidar com tamanhos de dados variados ou experimentar configurações de desempenho.

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

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

Quais configurações podem ser substituídas?

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

Configurações	Quando usar	Cenário de exemplo
Contagem de instâncias	Quando você tem volumes de dados variados	Use mais instâncias para conjuntos de dados maiores (10 instâncias para 1 milhão de arquivos versus 2 instâncias para 100.000 arquivos).
Tamanho do minilote	Quando você precisa equilibrar a taxa de transferência e o uso de memória	Use lotes menores (10 a 50 arquivos) para imagens grandes e lotes maiores (100 a 500 arquivos) para arquivos de texto pequenos.
Máximo de tentativas	Quando a qualidade dos dados varia	Tentativas mais altas (5 a 10) para dados ruidosos; tentativas inferiores (1 a 3) para dados limpos
Tempo Limite	Quando o tempo de processamento varia de acordo com o tipo de dados	Tempo limite maior (300s) para modelos complexos; tempo limite mais curto (30s) para modelos simples
Limite de erro	Quando você precisa de diferentes níveis de tolerância a falhas	Limite estrito (-1) para trabalhos críticos; limite de leniência (10%) para trabalhos experimentais

Como substituir as configurações

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

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

Adicionar implantações a um ponto de extremidade

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 para sua implantação em lote. Inclua as dependências que seu código precisa executar. Adicione a biblioteca azureml-core, pois ela é necessária para implantações em lote. A definição de ambiente a seguir inclui as bibliotecas necessárias para executar um modelo com 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-ubuntu22.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-ubuntu22.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".
Copie o conteúdo do arquivo deployment-keras/environment/conda.yaml do repositório GitHub para o portal.
1. Selecione Avançar até chegar à "Página de revisão".
2. Selecione Criar e aguarde até que o ambiente esteja pronto para uso.
O arquivo Conda usado tem a seguinte aparência:

deployment-keras/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-ubuntu22.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
```
```
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 controla a quantidade de dados que seu script de pontuação recebe em 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.
Selecione Avançar para prosseguir para a página "Código + ambiente".
1. 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.
2. Em Selecionar ambiente, selecione o ambiente que você criou em uma etapa anterior.
3. Selecione Avançar.
4. Na página Computação, selecione o cluster de computação criado em uma etapa anterior.
5. Em Contagem de instâncias, insira o número de instâncias de computação desejadas para a implantação. Nesse caso, use 2.
6. 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 $SAMPLE_INPUT_URI --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=Path(temp_data_path) / "data",
        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 precisar da implantação em lote antiga, exclua-a executando o código a seguir. O --yes sinalizador confirma 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 endpoint em lote e suas implementações subjacentes. Trabalhos de pontuação em lote não sã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)

Comentários

Esta página foi útil?

Last updated on 2025-08-04

Compartilhar via

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

Pré-requisitos

Clone o repositório de exemplos

Preparar seu sistema

Conecte-se ao seu 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

Noções básicas sobre o fluxo de dados

Invocar um ponto de extremidade em lote

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

Quais configurações podem ser substituídas?

Como substituir as configurações

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