Criar trabalhos e dados de entrada para pontos de extremidade em lote

Artigo
09/03/2024

Os pontos de extremidade em lotes permitem que você execute operações em lotes longas em grandes quantidades de dados. Os dados podem estar localizados em locais diferentes, como em regiões de dispersão. Determinados tipos de pontos de extremidade em lotes também podem receber parâmetros literais como entradas.

Este artigo descreve como especificar entradas de parâmetro para pontos de extremidade em lotes e criar trabalhos de implantação. O processo dá suporte ao trabalho com diferentes tipos de dados. Para obter alguns exemplos, confira Noções básicas sobre entradas e saídas.

Pré-requisitos

Para invocar um ponto de extremidade em lotes e criar trabalhos com sucesso, certifique-se de que você tenha concluído os seguintes pré-requisitos:

Um ponto de extremidade e implantação em lotes. Se você não tiver esses recursos, confira Implantar modelos para pontuação em pontos de extremidade em lotes para criar uma implantação.
Permissões para executar uma implantação de ponto de extremidade em lote. As funções de Cientista de Dados, Colaborador e Proprietário do AzureML podem ser usadas para executar uma implantação. Para obter definições de função personalizadas, confira Autorização em pontos de extremidade em lote para examinar as permissões necessárias específicas.
Um token válido do Microsoft Entra ID que representa uma entidade de segurança para invocar o ponto de extremidade. Essa entidade de segurança pode ser uma entidade de usuário ou uma entidade de serviço. Depois de invocar um ponto de extremidade, o Azure Machine Learning cria um trabalho de implantação em lotes na identidade associada ao token. Você pode usar suas próprias credenciais para a invocação, conforme descrito nos procedimentos a seguir.
- CLI do Azure
- Python
- REST
Use a CLI do Azure para entrar com autenticação interativa ou de código do dispositivo:
```
az login
```
Use o SDK do Azure Machine Learning para Python para fazer login:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient.from_config(DefaultAzureCredential())
```
Se a sua configuração for executada fora de uma computação do Azure Machine Learning, você precisará especificar o workspace em que o ponto de extremidade é implantado:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

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

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
```
A maneira mais simples de obter um token válido para sua conta de usuário é usar a CLI do Azure. Em um console, execute o seguinte comando da CLI do Azure:
```
az account get-access-token --resource https://ml.azure.com --query "accessToken" --output tsv
```
Dica

Quando você trabalha com REST, recomendamos invocar pontos de extremidade em lotes usando uma entidade de serviço. Para obter mais informações, confira Executar trabalhos usando uma entidade de serviço (REST) para saber como obter um token para uma entidade de serviço com REST.
Para saber mais sobre como iniciar trabalhos de implantação em lote usando diferentes tipos de credencial, confira Como executar trabalhos usando diferentes tipos de credenciais.
O cluster de cálculo em que o ponto de extremidade está implantado tem acesso para ler os dados inseridos.

Dica

Se você usar um armazenamento de dados sem credencial ou uma Conta de Armazenamento do Microsoft Azure externa como entrada de dados, certifique-se de configurar clusters de computação para acesso a dados. A identidade gerenciada do cluster de cálculo é usada para montar a conta de armazenamento. A identidade do trabalho (invocador) ainda é usada para ler os dados subjacentes, o que permite que você obtenha controle de acesso granular.

Criar noções básicas de trabalhos

Para criar um trabalho a partir de um ponto de extremidade em lotes, invoque o ponto de extremidade. A invocação pode ser feita usando a CLI do Azure, o SDK do Azure Machine Learning para Python ou uma chamada à API REST. Os exemplos a seguir mostram os conceitos básicos da invocação para um ponto de extremidade em lote que recebe uma única pasta de dados de entrada para processamento. Para obter exemplos com entradas e saídas diferentes, confira Noções básicas sobre entradas e saídas.

Use a operação invoke em pontos de extremidade em lote:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Use o método MLClient.batch_endpoints.invoke() para especificar o nome do experimento:

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data")
    }
)

Faça uma solicitação POST para a URL de invocação do ponto de extremidade. Você pode obter a URL de invocação no portal do Azure Machine Learning na página de detalhes do ponto de extremidade.

Corpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        }
    }
}

Solicitação

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Invocar uma implantação específica

Os pontos de extremidade do lote podem hospedar várias implantações no mesmo ponto de extremidade. O ponto de extremidade padrão é usado, a menos que o usuário especifique o contrário. Você pode alterar a implantação a ser usada com os procedimentos a seguir.

Use o argumento --deployment-name ou -d para especificar o nome da implantação:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --deployment-name $DEPLOYMENT_NAME \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Use o parâmetro deployment_name para especificar o nome da implantação:

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    deployment_name=deployment.name,
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data")
    }
)

Adicione o cabeçalho azureml-model-deployment à sua solicitação, incluindo o nome da implantação que você deseja invocar:

Corpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        }
    }
}

Solicitação

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
azureml-model-deployment: DEPLOYMENT_NAME

Configurar propriedades do trabalho

Você pode configurar algumas das propriedades no trabalho criado no momento da invocação.

Observação

Atualmente, a capacidade de configurar propriedades de trabalho está disponível apenas em pontos de extremidade em lotes com implantações de componente de pipeline.

Configurar o nome do experimento

Use os procedimentos a seguir para configurar o nome do experimento.

Use o argumento --experiment-name para especificar o nome do experimento:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --experiment-name "my-batch-job-experiment" \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Use o parâmetro experiment_name para especificar o nome do experimento:

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    experiment_name="my-batch-job-experiment",
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"),
    }
)

Indique o nome do experimento usando a chave experimentName na seção properties:

Corpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        },
        "properties":
        {
            "experimentName": "my-batch-job-experiment"
        }
    }
}

Solicitar

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Entender entradas e saídas

Os pontos de extremidade em lote fornecem uma API durável que os consumidores podem usar para criar trabalhos em lote. A mesma interface pode ser usada para especificar as entradas e saídas esperadas pela implantação. Use entradas para passar qualquer informação que seu ponto de extremidade precise para executar o trabalho.

Diagrama mostrando como as entradas e saídas são usadas em pontos de extremidade em lote.

Os pontos de extremidade do lote dão suporte a dois tipos de entradas:

Entradas de dados : ponteiros para um local de armazenamento ou ativo do Azure Machine Learning específicos.
Entradas literais: valores literais como números ou cadeias de caracteres que você deseja passar para o trabalho.

O número e o tipo de entradas e saídas dependem do tipo de implantação em lote. As implantações de modelo sempre requerem uma entrada de dados e produzem uma saída de dados. Não há suporte para entradas de literais. No entanto, as implantações de componentes do pipeline fornecem um constructo mais geral para criar pontos de extremidade e permitem que você especifique qualquer número de entradas (de dados e de literais) e saídas.

A tabela a seguir resume as entradas e saídas para implantações em lote:

Tipo de implantação	Número de entradas	Tipos de entrada com suporte	Número de saídas	Tipos de saída compatíveis
Implantação de modelo	1	Entradas de dados	1	Saídas de dados
Implantação do componente de pipeline	[0..N]	Entradas de dados e entradas literais	[0..N]	Saídas de dados

Dica

Entradas e saídas são sempre nomeadas. Os nomes servem como chaves para identificar os dados e passar o valor real durante a invocação. Como as implantações de modelo sempre exigem uma entrada e uma saída, o nome é ignorado durante a invocação. Você pode atribuir o nome que melhor descreve o seu caso de uso, como "sales_estimation".

Explorar entradas de dados

As entradas de dados referem-se a entradas que apontam para um local onde os dados são colocados. Como os pontos de extremidade em lotes geralmente consomem grandes quantidades de dados, você não pode passar os dados de entrada como parte da solicitação de invocação. Em vez disso, você especifica o local aonde o ponto de extremidade do lote deve ir para procurar os dados. Os dados de entrada são montados e transmitidos na computação de destino para melhorar o desempenho.

Os pontos de extremidade do Lote dão suporte à leitura de arquivos localizados nas seguintes opções de armazenamento:

Ativos de dados do Azure Machine Learning, incluindo Pasta (uri_folder) e Arquivo (uri_file).
Armazenamentos de dados do Azure Machine Learning, incluindo o Armazenamento de Blobs do Azure, o Azure Data Lake Storage Gen1 e o Azure Data Lake Storage Gen2.
Contas de Armazenamento do Azure, incluindo o Azure Data Lake Storage Gen1, o Azure Data Lake Storage Gen2 e o Armazenamento de Blobs do Azure.
Pastas/arquivos de dados locais (CLI do Azure Machine Learning ou SDK do Azure Machine Learning para Python). No entanto, essa operação faz com que os dados locais sejam carregados no armazenamento de dados padrão do Azure Machine Learning no workspace no qual você está trabalhando.

Importante

Aviso de substituição: conjuntos de dados do tipo FileDataset (V1) estão preteridos e serão desativados no futuro. Os pontos de extremidade em lotes existentes que dependem dessa funcionalidade continuarão funcionando. Os pontos de extremidade em lotes criados com GA CLIv2 (versão 2.4.0 e mais recentes) ou a API REST GA (versão 2022-05-01 e mais recentes) não darão suporte ao conjunto de dados V1.

Explorar entradas literais

Entradas literais referem-se a entradas que podem ser representadas e resolvidas no momento da invocação, como cadeias de caracteres, números e valores boolianos. Normalmente, você usa entradas literais para passar parâmetros para o ponto de extremidade como parte de uma implantação de componente de pipeline. Os pontos de extremidade do lote dão suporte aos seguintes tipos literais:

string
boolean
float
integer

As entradas de literais só têm suporte nas implantações de componentes do pipeline. Confira Criar trabalhos com entradas de literais para saber como especificá-las.

Explorar saídas de dados

As saídas de dados referem-se ao local em que os resultados de um trabalho em lote devem ser colocados. Cada saída tem um nome identificável e o Azure Machine Learning atribui automaticamente um caminho exclusivo a cada saída nomeada. Você pode especificar outro caminho, conforme necessário.

Importante

Os pontos de extremidade em lote só dão suporte à gravação de saídas nos armazenamentos de dados do Armazenamento de Blobs do Azure. Se precisar gravar em uma conta de armazenamento com namespaces hierárquicos habilitados (também conhecidos como Azure Datalake Gen2 ou ADLS Gen2), você poderá registrar o serviço de armazenamento como um armazenamento de dados do Armazenamento de Blobs do Azure porque os serviços são totalmente compatíveis. Dessa forma, você pode gravar saídas de pontos de extremidade em lote no ADLS Gen2.

Criar trabalhos com entradas de dados

Os exemplos a seguir mostram como criar trabalhos obtendo entradas de dados de ativos de dados, armazenamentos de dados e Contas de Armazenamento do Azure.

Usar dados de entrada do ativo de dados

Os ativos de dados do Azure Machine Learning (anteriormente conhecidos como conjuntos de dados) têm suporte como entradas para trabalhos. Siga estas etapas para executar um trabalho de ponto de extremidade em lotes usando dados armazenados em um ativo de dados registrado no Azure Machine Learning.

Aviso

No momento, os ativos de dados do tipo Tabela (MLTable) não são compatíveis no momento.

Em primeiro lugar, crie o ativo de dados. Este ativo de dados consiste em uma pasta com vários arquivos CSV que você processa em paralelo usando pontos de extremidade em lotes. Você pode ignorar essa etapa se seus dados já estiverem registrados como um ativo de dados.
- CLI do Azure
- Python
- REST
Crie uma definição de ativo de dados em YAML:

heart-dataset-unlabeled.yml
```
$schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: heart-dataset-unlabeled
description: An unlabeled dataset for heart classification.
type: uri_folder
path: heart-classifier-mlflow/data
```
Em seguida, crie o ativo de dados:
```
az ml data create -f heart-dataset-unlabeled.yml
```
Crie uma definição de ativo de dados:
```
data_path = "heart-classifier-mlflow/data"
dataset_name = "heart-dataset-unlabeled"

heart_dataset_unlabeled = Data(
    path=data_path,
    type=AssetTypes.URI_FOLDER,
    description="An unlabeled dataset for heart classification",
    name=dataset_name,
)
```
Crie o ativo de dados:
```
ml_client.data.create_or_update(heart_dataset_unlabeled)
```
Para obter o ativo de dados recém-criado, use o seguinte comando:
```
heart_dataset_unlabeled = ml_client.data.get(name=dataset_name, label="latest")
```
Use a CLI do Azure Machine Learning, o SDK do Azure Machine Learning para Python ou o estúdio do Azure Machine Learning para obter a localização (região), o workspace e o nome e a versão do ativo de dados. Você precisa desses itens para procedimentos posteriores.

Crie a entrada ou a solicitação:

DATASET_ID=$(az ml data show -n heart-dataset-unlabeled --label latest | jq -r .id)

input = Input(path=heart_dataset_unlabeled.id)

Corpo

{
    "properties": {
        "InputData": {
            "heart_dataset": {
                "JobInputType" : "UriFolder",
                "Uri": "azureml://locations/<location>/workspaces/<workspace>/data/<dataset_name>/versions/labels/latest"
            }
        }
    }
}

A ID dos ativos de dados é semelhante a /subscriptions/<subscription>/resourcegroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/data/<data-asset>/versions/<version>. Você também pode usar o formato azureml:<datasset_name>@latest para especificar a entrada.

Execute o ponto de extremidade:
- CLI do Azure
- Python
- REST
Use o argumento --set para especificar a entrada:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$DATASET_ID
```
Para um ponto de extremidade que serve uma implantação de modelo, você pode usar o argumento --input para especificar a entrada de dados porque uma implantação de modelo sempre requer apenas uma entrada de dados.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $DATASET_ID
```
O argumento --set tende a produzir comandos longos quando várias entradas são especificadas. Nesses casos, coloque suas entradas em um arquivo YAML e use o argumento --file para especificar as entradas necessárias para a invocação do ponto de extremidade.

inputs.yml
```
inputs:
  heart_dataset: azureml:/<datasset_name>@latest
```
Execute o comando a seguir:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Dica

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

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

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

Chame o método invoke usando o parâmetro inputs para especificar as entradas necessárias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique ainda mais a chamada invoke para uma implantação de modelo usando o parâmetro input para especificar o local para os dados de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Solicitar
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Usar dados de entrada de armazenamentos de dados

Você pode referenciar diretamente dados de armazenamentos de dados registrados do Azure Machine Learning com trabalhos de implantações em lotes. Nesse exemplo, você primeiro carrega alguns dados no armazenamento de dados padrão do workspace do Azure Machine Learning e, a seguir, executa uma implantação em lote nele. Siga essas etapas para executar um trabalho de ponto de extremidade em lote usando os dados armazenados em um armazenamento de dados.

Acesse o armazenamento de dados padrão do workspace do Azure Machine Learning. Se seus dados estiverem em um armazenamento diferente, use esse armazenamento. Você não precisa usar o armazenamento de dados padrão.
- CLI do Azure
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
A ID do armazenamento de dados se parece com /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Use a CLI do Azure Machine Learning, o SDK do Azure Machine Learning para Python ou o estúdio para obter as informações do armazenamento de dados.
Dica

O armazenamento de dados de blob padrão em um workspace é chamado de workspaceblobstore. Você poderá ignorar esta etapa se já souber a ID do recurso do armazenamento de dados padrão em seu workspace.
Carregue alguns dados de exemplo no armazenamento de dados.

Este exemplo pressupõe que você já carregou os dados de exemplo incluídos no repositório na pasta sdk/python/endpoints/batch/deploy-models/heart-classifier-mlflow/data na pasta heart-disease-uci-unlabeled na conta do Armazenamento de Blobs. Conclua esta etapa antes de continuar.
Crie a entrada ou a solicitação:
- CLI do Azure
- Python
- REST
Coloque o caminho do arquivo na variável INPUT_PATH:
```
DATA_PATH="heart-disease-uci-unlabeled"
INPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"
```
Coloque o caminho do arquivo na variável input:
```
data_path = "heart-disease-uci-unlabeled"
input = Input(type=AssetTypes.URI_FOLDER, path=f"{default_ds.id}/paths/{data_path})
```
Se os dados forem um arquivo, altere o tipo de entrada para type=AssetTypes.URI_FILE.
Corpo
```
{
    "properties": {
        "InputData": {
            "heart_dataset": {
                "JobInputType" : "UriFolder",
                "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
            }
        }
    }
}
```
Se os dados forem um arquivo, use o tipo UriFile para a entrada.
Observe como a variável paths do caminho é acrescentada à ID do recurso do armazenamento de dados. Este formato indica que o valor a seguir é um caminho.

Dica

Você também pode usar o formato azureml://datastores/<data-store>/paths/<data-path> para especificar a entrada.
Execute o ponto de extremidade:
- CLI do Azure
- Python
- REST
Use o argumento --set para especificar a entrada:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_PATH
```
Para um ponto de extremidade que serve uma implantação de modelo, você pode usar o argumento --input para especificar a entrada de dados porque uma implantação de modelo sempre requer apenas uma entrada de dados.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_PATH --input-type uri_folder
```
O argumento --set tende a produzir comandos longos quando várias entradas são especificadas. Nesses casos, coloque suas entradas em um arquivo YAML e use o argumento --file para especificar as entradas necessárias para a invocação do ponto de extremidade.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: azureml://datastores/<data-store>/paths/<data-path>
```
Execute o comando a seguir:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Se os dados forem um arquivo, use o tipo uri_file para a entrada.
Dica

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

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

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

Chame o método invoke usando o parâmetro inputs para especificar as entradas necessárias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique ainda mais a chamada invoke para uma implantação de modelo usando o parâmetro input para especificar o local para os dados de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Solicitar
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Usar dados de entrada de contas de Armazenamento do Microsoft Azure

Os pontos de extremidade em lote do Azure Machine Learning podem ler dados de locais de nuvem nas contas do Armazenamento do Azure, tanto pública quanto privada. Use as etapas a seguir para executar um trabalho de ponto de extremidade em lotes com dados armazenados em uma conta de armazenamento.

Para saber mais sobre a configuração extra necessária para ler dados de contas de armazenamento, confira Configurar clusters de computação para acesso a dados.

Crie a entrada ou a solicitação:

Defina a variável INPUT_DATA:

INPUT_DATA = "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"

Se os dados forem um arquivo, defina a variável com o seguinte formato:

INPUT_DATA = "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"

Defina a variável input:

input = Input(
    type=AssetTypes.URI_FOLDER, 
    path="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
)

Se os dados forem um arquivo, altere o tipo de entrada para type=AssetTypes.URI_FILE:

input = Input(
    type=AssetTypes.URI_FILE,
    path="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
)

Corpo

{
   "properties": {
       "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
       }
   }
}

Se os dados forem um arquivo, altere o tipo de entrada para JobInputType:

Corpo

{
   "properties": {
       "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFile",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
           }
       }
   }
}

Execute o ponto de extremidade:
- CLI do Azure
- Python
- REST
Use o argumento --set para especificar a entrada:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_DATA
```
Para um ponto de extremidade que serve uma implantação de modelo, você pode usar o argumento --input para especificar a entrada de dados porque uma implantação de modelo sempre requer apenas uma entrada de dados.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_DATA --input-type uri_folder
```
O argumento --set tende a produzir comandos longos quando várias entradas são especificadas. Nesses casos, coloque suas entradas em um arquivo YAML e use o argumento --file para especificar as entradas necessárias para a invocação do ponto de extremidade.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data
```
Execute o comando a seguir:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Se os dados forem um arquivo, use o tipo uri_file para a entrada.
Dica

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

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

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

Chame o método invoke usando o parâmetro inputs para especificar as entradas necessárias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique ainda mais a chamada invoke para uma implantação de modelo usando o parâmetro input para especificar o local para os dados de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Solicitação
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Criar trabalhos com entradas literais

As implantações de componente de pipeline podem aceitar entradas literais. O exemplo a seguir mostra como especificar uma entrada chamada score_mode, do tipo string, com um valor de append:

Coloque suas entradas em um arquivo YAML e use --file para especificar as entradas necessárias para a invocação do seu ponto de extremidade.

inputs.yml

inputs:
  score_mode:
    type: string
    default: append

Execute o comando a seguir:

az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml

Você também pode usar o argumento --set para especificar o valor. No entanto, esta abordagem tende a produzir comandos longos quando várias entradas são especificadas:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.score_mode.type="string" inputs.score_mode.default="append"

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, 
    inputs = { 
        'score_mode': Input(type="string", default="append")
        }
)

Corpo

{
    "properties": {
        "InputData": {
            "score_mode": {
                "JobInputType" : "Literal",
                "Value": "append"
            }
        }
    }
}

Solicitação

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Criar trabalhos com saídas de dados

O exemplo a seguir mostra como alterar o local em que uma saída chamada score é colocada. Para integridade, esses exemplos também configuram uma entrada chamada heart_dataset.

Salve a saída usando o armazenamento de dados padrão no workspace do Azure Machine Learning. Você pode usar qualquer outro armazenamento de dados em seu workspace, desde que seja uma conta de Armazenamento de Blobs.
- CLI do Azure
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
A ID do armazenamento de dados se parece com /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Use a CLI do Azure Machine Learning, o SDK do Azure Machine Learning para Python ou o estúdio para obter as informações do armazenamento de dados.

Criar uma saída de dados:

Defina a variável OUTPUT_PATH:

DATA_PATH="batch-jobs/my-unique-path"
OUTPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"

Para que o processo fique completo, você também deve criar uma entrada de dados:

INPUT_PATH="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"

Defina a variável de caminho output:

data_path = "batch-jobs/my-unique-path"
output = Output(type=AssetTypes.URI_FILE, path=f"{default_ds.id}/paths/{data_path})

Para que a opção esteja completa, vamos também criar uma entrada de dados:

input="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"

Corpo

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        },
        "OutputData": {
            "score": {
                "JobOutputType" : "UriFile",
                "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
            }
        }
    }
}

Observação

Observe como a variável paths do caminho é acrescentada à ID do recurso do armazenamento de dados. Este formato indica que o valor a seguir é um caminho.

Execute a implantação:

Use o argumento --set para especificar a entrada:

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.path=$INPUT_PATH \
    --set outputs.score.path=$OUTPUT_PATH

job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   inputs={ "heart_dataset": input },
   outputs={ "score": output }
)

Solicitar

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Compartilhar via

Criar trabalhos e dados de entrada para pontos de extremidade em lote

Pré-requisitos

Criar noções básicas de trabalhos

Invocar uma implantação específica

Configurar propriedades do trabalho

Configurar o nome do experimento

Entender entradas e saídas

Explorar entradas de dados

Explorar entradas literais

Explorar saídas de dados

Criar trabalhos com entradas de dados

Usar dados de entrada do ativo de dados

Usar dados de entrada de armazenamentos de dados

Usar dados de entrada de contas de Armazenamento do Microsoft Azure

Criar trabalhos com entradas literais

Criar trabalhos com saídas de dados

Comentários

Recursos adicionais

Compartilhar via

Criar trabalhos e dados de entrada para pontos de extremidade em lote

Pré-requisitos

Criar noções básicas de trabalhos

Invocar uma implantação específica

Configurar propriedades do trabalho

Configurar o nome do experimento

Entender entradas e saídas

Explorar entradas de dados

Explorar entradas literais

Explorar saídas de dados

Criar trabalhos com entradas de dados

Usar dados de entrada do ativo de dados

Usar dados de entrada de armazenamentos de dados

Usar dados de entrada de contas de Armazenamento do Microsoft Azure

Criar trabalhos com entradas literais

Criar trabalhos com saídas de dados

Conteúdo relacionado

Comentários

Recursos adicionais