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

Artigo
09/01/2024

Os pontos de extremidade em lote permitem que você execute operações em lote longas em grandes quantidades de dados. Os dados podem ser localizados em diferentes locais, como em regiões dispersas. Certos tipos de pontos de extremidade em lote também podem receber parâmetros literais como entradas.

Este artigo descreve como especificar entradas de parâmetros para pontos de extremidade em lote e criar trabalhos de implantação. O processo suporta o trabalho com diferentes tipos de dados. Para obter alguns exemplos, consulte Compreender entradas e saídas.

Pré-requisitos

Para invocar com êxito um ponto de extremidade em lote e criar trabalhos, certifique-se de concluir os seguintes pré-requisitos:

Um ponto de extremidade e implantação em lote. Se você não tiver esses recursos, consulte Implantar modelos para pontuação em pontos de extremidade em lote 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, consulte Autorização em pontos de extremidade em lote para revisar as permissões específicas necessárias.
Um token de ID do Microsoft Entra válido 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 lote sob a 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 de dispositivo:
```
az login
```
Use o SDK do Azure Machine Learning para Python para entrar:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient.from_config(DefaultAzureCredential())
```
Se sua configuração for executada fora de uma computação do Azure Machine Learning, você precisará especificar o espaço de trabalho onde o ponto de extremidade será 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
```
Gorjeta

Quando você trabalha com REST, recomendamos invocar pontos de extremidade em lote usando uma entidade de serviço. Para obter mais informações, consulte Executando 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 credenciais, consulte Como executar trabalhos usando diferentes tipos de credenciais.
O cluster de computação onde o ponto de extremidade é implantado tem acesso para ler os dados de entrada.

Gorjeta

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

Criar noções básicas de empregos

Para criar um trabalho a partir de um ponto de extremidade em lote, 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 de API REST. Os exemplos a seguir mostram os conceitos básicos de invocação para um ponto de extremidade em lote que recebe uma única pasta de dados de entrada para processamento. Para obter exemplos com diferentes entradas e saídas, consulte Compreender entradas e saídas.

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

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

Use o MLClient.batch_endpoints.invoke() método 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 POST solicitação para a URL de invocação do ponto de extremidade. Você pode obter a URL de invocação do 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"
           }
        }
    }
}

Pedir

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 em lote podem hospedar várias implantações sob o 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 para usar 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"
           }
        }
    }
}

Pedir

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.

Nota

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

Configurar 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 experimentName chave na properties seção:

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

Pedir

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

Compreender 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 sua implantação. Use entradas para passar qualquer informação que seu ponto de extremidade precisa para executar o trabalho.

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

Os pontos de extremidade em lote suportam dois tipos de entradas:

Entradas de dados: ponteiros para um local de armazenamento específico ou ativo do Azure Machine Learning.
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 exigem uma entrada de dados e produzem uma saída de dados. Não há suporte para entradas literais. No entanto, as implantações de componentes de pipeline fornecem uma construção mais geral para criar pontos de extremidade e permitem especificar qualquer número de entradas (dados e literais) e saídas.

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

Tipo de implementação	Número de entradas	Tipos de entrada suportados	Número de saídas	Tipos de saída suportados
Implantação do modelo	1	Introdução de dados	1	Saídas de dados
Implantação de componentes de pipeline	[0..N]	Entradas de dados e entradas literais	[0..N]	Saídas de dados

Gorjeta

As 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 seu caso de uso, como "sales_estimation".

Explore 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 lote geralmente consomem grandes quantidades de dados, não é possível passar os dados de entrada como parte da solicitação de invocação. Em vez disso, você especifica o local onde 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 em lote suportam a 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 Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2 e Azure Blob Storage.
Pastas/arquivos de dados locais (CLI do Azure Machine Learning ou SDK do Azure Machine Learning para Python). No entanto, essa operação resulta nos dados locais a serem carregados no Repositório de Dados do Azure Machine Learning padrão do espaço de trabalho em que você está trabalhando.

Importante

Aviso de descontinuação: os conjuntos de dados do tipo FileDataset (V1) foram preteridos e serão desativados no futuro. Os pontos de extremidade em lote existentes que dependem dessa funcionalidade continuarão a funcionar. Os pontos de extremidade em lote criados com GA CLIv2 (2.4.0 e mais recente) ou GA REST API (2022-05-01 e mais recente) não suportarão o conjunto de dados V1.

Explore 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 booleanos. Normalmente, você usa entradas literais para passar parâmetros para seu ponto de extremidade como parte de uma implantação de componente de pipeline. Os pontos de extremidade em lote suportam os seguintes tipos literais:

string
boolean
float
integer

As entradas literais só são suportadas em implantações de componentes de pipeline. Consulte Criar trabalhos com entradas literais para saber como especificá-los.

Explore saídas de dados

As saídas de dados referem-se ao local onde 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 dão suporte apenas à gravação de saídas em armazenamentos de dados do Armazenamento de Blob do Azure. Se você precisar gravar em uma conta de armazenamento com namespaces hierárquicos habilitados (também conhecido como Azure Datalake Gen2 ou ADLS Gen2), poderá registrar o serviço de armazenamento como um armazenamento de dados do Armazenamento de Blob do Azure porque os serviços são totalmente compatíveis. Dessa forma, você pode gravar saídas de pontos de extremidade em lote para o 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) são suportados como entradas para trabalhos. Siga estas etapas para executar um trabalho de ponto de extremidade em lote usando dados armazenados em um ativo de dados registrado no Aprendizado de Máquina do Azure.

Aviso

Atualmente, não há suporte para ativos de dados do tipo Tabela (MLTable).

Primeiro, crie o ativo de dados. Esse ativo de dados consiste em uma pasta com vários arquivos CSV que você processa em paralelo usando pontos de extremidade em lote. Você pode pular esta 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 o local (região), o espaço de trabalho e o nome e a versão do ativo de dados. Você precisa desses itens para procedimentos posteriores.

Crie a entrada ou 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"
            }
        }
    }
}

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

Execute o ponto de extremidade:
- CLI do Azure
- Python
- REST
Use o --set argumento 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 --input argumento 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 YAML arquivo e use o --file argumento para especificar as entradas necessárias para sua chamada de ponto de extremidade.

inputs.yml
```
inputs:
  heart_dataset: azureml:/<datasset_name>@latest
```
Execute o seguinte comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
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.

Chame o invoke método usando o inputs parâmetro para especificar as entradas necessárias:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Simplifique ainda mais a invoke chamada para uma implantação de modelo usando o input parâmetro para especificar o local para os dados de entrada:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Pedir
```
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 fazer referência direta a dados de armazenamentos de dados registrados do Azure Machine Learning com trabalhos de implantações em lote. Neste exemplo, você primeiro carrega alguns dados no armazenamento de dados padrão no espaço de trabalho do Aprendizado de Máquina do Azure e, em seguida, executa uma implantação em lote nele. Siga estas etapas para executar um trabalho de ponto de extremidade em lote usando dados armazenados em um armazenamento de dados.

Acesse o armazenamento de dados padrão no espaço de trabalho do Azure Machine Learning. Se seus dados estiverem em um armazenamento diferente, você poderá usá-lo. Não é necessário usar o armazenamento de dados padrão.
- CLI do Azure
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
O ID do armazenamento de dados é semelhante ao /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.
Gorjeta

O armazenamento de dados de blob padrão em um espaço de trabalho é chamado workspaceblobstore. Você pode ignorar esta etapa se já souber a ID do recurso do armazenamento de dados padrão em seu espaço de trabalho.
Carregue alguns dados de exemplo para o 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 conta heart-disease-uci-unlabeled de Armazenamento de Blob. Certifique-se de concluir esta etapa antes de continuar.
Crie a entrada ou solicitação:
- CLI do Azure
- Python
- REST
Coloque o caminho do INPUT_PATH arquivo na variável:
```
DATA_PATH="heart-disease-uci-unlabeled"
INPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"
```
Coloque o caminho do input arquivo na variável:
```
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 UriFile tipo para a entrada.
Observe como a paths variável para o caminho é anexada à ID do recurso do armazenamento de dados. Esse formato indica que o valor a seguir é um caminho.

Gorjeta

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 --set argumento 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 --input argumento 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 YAML arquivo e use o --file argumento para especificar as entradas necessárias para sua chamada de ponto de extremidade.

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

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

Usar dados de entrada das Contas de Armazenamento do Azure

Os pontos de extremidade em lote do Azure Machine Learning podem ler dados de locais de nuvem nas Contas de Armazenamento do Azure, tanto públicas quanto privadas. Use as etapas a seguir para executar um trabalho de ponto de extremidade em lote 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, consulte Configurar clusters de computação para acesso a dados.

Crie a entrada ou solicitação:

Defina a INPUT_DATA variável:

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 input variável:

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 --set argumento 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 --input argumento 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 --set argumento tende a produzir comandos longos quando várias entradas são especificadas. Nesses casos, coloque suas entradas em um YAML arquivo e use o --file argumento para especificar as entradas necessárias para sua chamada de 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 seguinte comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Se os dados forem um arquivo, use o uri_file tipo para a entrada.
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.

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

Crie trabalhos com entradas literais

As implantações de componentes de pipeline podem ter 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 YAML arquivo e use --file para especificar as entradas necessárias para sua chamada de ponto de extremidade.

inputs.yml

inputs:
  score_mode:
    type: string
    default: append

Execute o seguinte comando:

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

Você também pode usar o --set argumento para especificar o valor. No entanto, essa 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"
            }
        }
    }
}

Pedir

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 onde uma saída nomeada score é colocada. Para completar, esses exemplos também configuram uma entrada chamada heart_dataset.

Salve a saída usando o armazenamento de dados padrão no espaço de trabalho do Azure Machine Learning. Você pode usar qualquer outro armazenamento de dados em seu espaço de trabalho, desde que seja uma conta de Armazenamento de Blob.
- CLI do Azure
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
O ID do armazenamento de dados é semelhante ao /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.

Crie uma saída de dados:

Defina a OUTPUT_PATH variável:

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

Para completar, crie também uma entrada de dados:

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

Defina a output variável de caminho:

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

Para completar, 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>"
            }
        }
    }
}

Nota

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

Execute a implantação:

Use o --set argumento 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 }
)

Pedir

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

Partilhar via

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

Pré-requisitos

Criar noções básicas de empregos

Invocar uma implantação específica

Configurar propriedades do trabalho

Configurar nome do experimento

Compreender entradas e saídas

Explore entradas de dados

Explore entradas literais

Explore 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 das Contas de Armazenamento do Azure

Crie trabalhos com entradas literais

Criar trabalhos com saídas de dados

Comentários

Recursos adicionais

Partilhar via

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

Pré-requisitos

Criar noções básicas de empregos

Invocar uma implantação específica

Configurar propriedades do trabalho

Configurar nome do experimento

Compreender entradas e saídas

Explore entradas de dados

Explore entradas literais

Explore 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 das Contas de Armazenamento do Azure

Crie trabalhos com entradas literais

Criar trabalhos com saídas de dados

Conteúdos relacionados

Comentários

Recursos adicionais