Creare processi e inserire dati negli endpoint batch

Articolo
10/16/2024

Gli endpoint batch consentono di eseguire operazioni batch lunghe su grandi quantità di dati. I dati possono trovarsi in posizioni diverse, ad esempio in aree diverse. Determinati tipi di endpoint batch possono anche ricevere parametri letterali come input.

Questo articolo descrive come specificare gli input dei parametri per gli endpoint batch e creare i processi di distribuzione. Il processo supporta l'uso di diversi tipi di dati. Per alcuni esempi, vedere Informazioni su input e output.

Prerequisiti

Per richiamare correttamente un endpoint batch e creare processi, accertare di completare i prerequisiti seguenti:

Endpoint e distribuzione batch. Se queste risorse non sono disponibili, vedere Distribuire modelli per il punteggio negli endpoint batch per creare una distribuzione.
Autorizzazioni per eseguire una distribuzione di endpoint batch. I ruoli di data scientist, collaboratore e proprietario di AzureML possono essere usati per eseguire una distribuzione. Per le definizioni di ruolo personalizzate, vedere Autorizzazione negli endpoint batch per esaminare le autorizzazioni necessarie specifiche.
Un token Microsoft Entra ID valido che rappresenta un'entità di sicurezza per richiamare l'endpoint. L'entità può essere un'entità utente o un'entità servizio. Dopo aver richiamato un endpoint, Azure Machine Learning crea un processo di distribuzione batch con l'identità associata al token. Per la chiamata è possibile usare le proprie credenziali, come descritto nelle procedure seguenti.
Usare l'interfaccia della riga di comando di Azure per accedere con autenticazione interattiva o con codice dispositivo:
```
az login
```
Usare Azure Machine Learning SDK per Python per eseguire l'accesso:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient.from_config(DefaultAzureCredential())
```
Se la configurazione viene eseguita all'esterno di un calcolo di Azure Machine Learning, è necessario specificare l'area di lavoro in cui viene distribuito l'endpoint:
```
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)
```
Il modo più semplice per ottenere un token valido per l'account utente consiste nell'usare l'interfaccia della riga di comando di Azure. In una console eseguire il comando seguente dell'interfaccia della riga di comando di Azure:
```
az account get-access-token --resource https://ml.azure.com --query "accessToken" --output tsv
```
Suggerimento

Quando si lavora con REST, è consigliabile richiamare gli endpoint batch usando un'entità servizio. Per altre informazioni, vedere Esecuzione di processi tramite un'entità servizio (REST) per informazioni su come ottenere un token per un'entità servizio con REST.
Per altre informazioni su come avviare processi di distribuzione batch, usando diversi tipi di credenziali, vedere Come eseguire processi usando tipi diversi di credenziali.
Il cluster di elaborazione in cui viene distribuito l'endpoint ha accesso per leggere i dati di input.

Suggerimento

Se si usa un archivio dati senza credenziali o un account di Archiviazione di Azure esterno come input di dati, assicurarsi di configurare i cluster di elaborazione per l'accesso ai dati. L'identità gestita del cluster di elaborazione viene usata per il montaggio dell'account di archiviazione. L'identità del processo (invoker) viene comunque usata per leggere i dati sottostanti, consentendo di ottenere un controllo di accesso granulare.

Nozioni di base sulla creazione di processi

Per creare un processo da un endpoint batch, richiamare l'endpoint. La chiamata può essere eseguita usando l'interfaccia della riga di comando di Azure, Azure Machine Learning SDK per Python o una chiamata API REST. Negli esempi seguenti vengono illustrati i concetti di base della chiamata per un endpoint batch che riceve una singola cartella di dati di input per l'elaborazione. Per esempi con input e output diversi, vedere Informazioni su input e output.

Usare l'operazione invoke negli endpoint batch:

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

Usare il metodo MLClient.batch_endpoints.invoke() per specificare il nome dell'esperimento:

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

Effettuare una richiesta POST all'URL di chiamata dell'endpoint. È possibile ottenere l'URL di chiamata dal portale di Azure Machine Learning nella pagina dei dettagli dell'endpoint.

Testo

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

Richiedi

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

Richiamare una distribuzione specifica

Gli endpoint batch possono ospitare più distribuzioni nello stesso endpoint. Viene usato l'endpoint predefinito, a meno che l'utente non specifichi diversamente. È possibile modificare la distribuzione da usare con le procedure seguenti.

Usare l'argomento --deployment-name o -d per specificare il nome della distribuzione:

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

Usare il parametro deployment_name per specificare il nome della distribuzione:

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

Aggiungere l'intestazione azureml-model-deployment alla richiesta, incluso il nome della distribuzione che si desidera richiamare:

Testo

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

Richiedi

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

Configurare le proprietà del processo

È possibile configurare alcune delle proprietà nel processo creato in fase di chiamata.

Nota

Attualmente la possibilità di configurare le proprietà del processo è disponibile solo negli endpoint batch con distribuzioni dei componenti Pipeline.

Configurare il nome dell'esperimento

Utilizzare le procedure seguenti per configurare il nome dell'esperimento.

Usare l'argomento --experiment-name per specificare il nome dell'esperimento:

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

Usare il parametro experiment_name per specificare il nome dell'esperimento:

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

Indicare il nome dell'esperimento usando la chiave experimentName nella sezione properties:

Testo

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

Richiedi

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

Spiegare input e output

Gli endpoint batch forniscono un'API durevole che i consumer possono usare per creare processi batch. La stessa interfaccia può essere usata per specificare gli input e gli output previsti dalla distribuzione. Usare gli input per passare all'endpoint le informazioni necessarie per eseguire il processo.

Diagramma che mostra come vengono usati input e output negli endpoint batch.

Gli endpoint batch supportano due tipi di input:

Input di dati: puntatori a un percorso di archiviazione specifico o a un asset di Azure Machine Learning.
Input letterali: valori letterali, ad esempio, numeri o stringhe che si desidera passare al processo.

Il numero e il tipo di input e output dipendono dal tipo di distribuzione batch. Le distribuzioni di modelli richiedono sempre un input di dati e producono un output dei dati. Gli input letterali non sono supportati. Tuttavia, le distribuzioni dei componenti della pipeline forniscono un costrutto più generale per compilare gli endpoint e consentono di specificare un numero qualsiasi di input (dati e valori letterali) e output.

La tabella seguente riepiloga gli input e gli output per le distribuzioni batch:

Tipo di distribuzione	Numero di input	Tipi di input supportati	Numero di output	Tipi di output supportati
Distribuzione di modelli	1	Input dei dati	1	Output dei dati
Distribuzione di componenti della pipeline	[0..N]	Input di dati e input letterali	[0..N]	Output dei dati

Suggerimento

Gli input e gli output sono sempre denominati. I nomi fungono da chiavi per identificare i dati e passare il valore effettivo durante la chiamata. Poiché le distribuzioni di modelli richiedono sempre un input e un output, durante la chiamata il nome viene ignorato. È possibile assegnare il nome che descrive meglio il caso d'uso, ad esempio "sales_estimation".

Esplorare gli input dei dati

Gli input di dati fanno riferimento agli input che puntano a un percorso in cui vengono inseriti i dati. Poiché gli endpoint batch usano in genere grandi quantità di dati, non è possibile passare i dati di input come parte della richiesta di chiamata. Specificare invece il percorso in cui l'endpoint batch deve cercare i dati. I dati di input vengono montati e trasmessi nel calcolo di destinazione per migliorare le prestazioni.

Gli endpoint batch supportano la lettura dei file che si trovano nelle opzioni di archiviazione seguenti:

Asset di dati di Azure Machine Learning, tra cui Cartella (uri_folder) e File (uri_file).
Archivi dati di Azure Machine Learning, tra cui Archiviazione BLOB di Azure, Azure Data Lake Storage Gen1 e Azure Data Lake Storage Gen2.
Account di archiviazione di Azure, tra cui Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2 e Archiviazione Blob di Azure.
Cartelle/file di dati locali (interfaccia della riga di comando di Azure Machine Learning o Azure Machine Learning SDK per Python). Tuttavia, questa operazione comporta il caricamento dei dati locali nell'archivio dati predefinito di Azure Machine Learning dell'area di lavoro su cui si sta lavorando.

Importante

Avviso di deprecazione: i set di dati di tipo FileDataset (V1) sono deprecati e verranno ritirati in futuro. Gli endpoint batch esistenti che si basano su questa funzionalità continueranno a funzionare. Gli endpoint batch creati con disponibilità generale CLIv2 (2.4.0 e versioni successive) o con disponibilità generali API REST (2022-05-01 e versioni successive) non supporteranno il set di dati V1.

Esplorare gli input letterali

Gli input letterali fanno riferimento a input che possono essere rappresentati e risolti in fase di chiamata, ad esempio stringhe, numeri e valori booleani. In genere, si usano input letterali per passare parametri all'endpoint come parte della distribuzione di un componente della pipeline. Gli endpoint batch supportano i tipi letterali seguenti:

string
boolean
float
integer

Gli input letterali sono supportati solo nelle distribuzioni dei componenti della pipeline. Per informazioni su come specificarli, vedere Creare processi con input letterali.

Esplorare gli output dei dati

Gli output dei dati fanno riferimento al percorso in cui devono essere inseriti i risultati di un processo batch. Ogni output ha un nome identificabile e Azure Machine Learning assegna automaticamente un percorso univoco a ciascun output denominato. È possibile specificare un altro percorso, se necessario.

Importante

Gli endpoint batch supportano solo la scrittura di output negli archivi dati di Archiviazione Blob di Azure. Se è necessario scrivere in un account di archiviazione con spazi dei nomi gerarchici abilitati (noti anche come Azure Datalake Gen2 o ADLS Gen2), è possibile registrare il servizio di archiviazione come archivio dati di Archiviazione BLOB di Azure perché i servizi sono completamente compatibili. In questo modo, è possibile scrivere output dagli endpoint batch in ADLS Gen2.

Creare processi con input di dati

Gli esempi seguenti illustrano come creare processi, accettando input di dati da asset di dati, archivi dati e account di archiviazione di Azure.

Usare i dati di input dall'asset di dati

Gli asset di dati di Azure Machine Learning (noti in precedenza come set di dati) sono supportati come input per i processi. Seguire questa procedura per eseguire un processo di endpoint batch usando i dati archiviati in un asset di dati registrato in Azure Machine Learning.

Avviso

Gli asset di dati di tipo Tabella (MLTable) non sono attualmente supportati.

Innanzitutto, creare l'asset di dati. Questo asset di dati è costituito da una cartella con più file CSV da elaborare in parallelo usando endpoint batch. È possibile ignorare questo passaggio se i dati sono già registrati come asset di dati.
Creare una definizione di asset di dati in 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
```
Creare quindi l'asset di dati:
```
az ml data create -f heart-dataset-unlabeled.yml
```
Creare una definizione dell'asset di dati:
```
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,
)
```
Creare l'asset di dati:
```
ml_client.data.create_or_update(heart_dataset_unlabeled)
```
Per ottenere l'asset di dati appena creato, usare il comando seguente:
```
heart_dataset_unlabeled = ml_client.data.get(name=dataset_name, label="latest")
```
Usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python o studio di Azure Machine Learning per ottenere il percorso (area), l'area di lavoro e il nome e la versione degli asset di dati. Questi elementi sono necessari per le procedure successive.

Creare l'input o la richiesta:

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

input = Input(path=heart_dataset_unlabeled.id)

Testo

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

L'ID degli asset di dati è simile a/subscriptions/<subscription>/resourcegroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/data/<data-asset>/versions/<version>. È anche possibile usare il formato azureml:<datasset_name>@latest per specificare l'input.

Eseguire l'endpoint:
Usare l'argomento --set per specificare l'input:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$DATASET_ID
```
Per un endpoint che gestisce una distribuzione del modello, è possibile usare l'argomento --input per specificare l'input dei dati, perché una distribuzione del modello richiede sempre un solo input di dati.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $DATASET_ID
```
L'argomento --set tende a produrre comandi lunghi quando vengono specificati diversi input. In questi casi, inserire gli input in un file YAML e usare l'argomento --file per specificare gli input necessari per la chiamata all'endpoint.

inputs.yml
```
inputs:
  heart_dataset: azureml:/<datasset_name>@latest
```
Esegui questo comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Suggerimento

Qual è la differenza tra il parametro inputs e input quando si richiama un endpoint?

In generale, è possibile usare un parametro inputs = {} del dizionario con il metodo invoke per fornire un numero arbitrario di input necessari a un endpoint batch che contiene una distribuzione modello o una distribuzione pipeline.

Per una distribuzione modello, è possibile usare il parametro input come modo più breve per specificare la posizione dei dati di input per la distribuzione. Questo approccio funziona perché una distribuzione del modello accetta sempre un solo input di dati.

Chiamare il metodo invoke usando il parametro inputs per specificare gli input necessari:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Semplificare ulteriormente la chiamata invoke per una distribuzione del modello usando il parametro inputper specificare il percorso per i dati di input:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Richiedi
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Usare i dati di input dagli archivi dati

È possibile fare riferimento direttamente ai dati dagli archivi dati registrati di Azure Machine Learning con i processi di distribuzione batch. In questo esempio si caricano prima alcuni dati nell'archivio dati predefinito nell'area di lavoro di Azure Machine Learning e quindi si eseguirà una distribuzione batch. Seguire questa procedura per eseguire un processo di endpoint batch usando i dati archiviati in un archivio dati.

Accedere all'archivio dati predefinito nell'area di lavoro di Azure Machine Learning. Se i dati si trovano in un archivio diverso, è possibile usare tale archivio. Non è necessario usare l'archivio dati predefinito.
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
L'ID degli archivi dati è simile a /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python, o Studio per ottenere le informazioni sull'archivio dati.
Suggerimento

L'archivio dati BLOB predefinito in un'area di lavoro è denominato workspaceblobstore. È possibile ignorare questo passaggio se si conosce già l'ID risorsa dell'archivio dati predefinito nell'area di lavoro.
Caricare alcuni dati di esempio nell'archivio dati.

Questo esempio presuppone che siano già stati caricati i dati di esempio inclusi nel repository nella cartella sdk/python/endpoints/batch/deploy-models/heart-classifier-mlflow/data nella cartella heart-disease-uci-unlabeled nell'account di archiviazione BLOB. Prima di continuare, assicurarsi di completare questo passaggio.
Creare l'input o la richiesta:
Posizionare il percorso del file nella variabile INPUT_PATH:
```
DATA_PATH="heart-disease-uci-unlabeled"
INPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"
```
Posizionare il percorso del file nella variabile input:
```
data_path = "heart-disease-uci-unlabeled"
input = Input(type=AssetTypes.URI_FOLDER, path=f"{default_ds.id}/paths/{data_path})
```
Se i dati sono un file, modificare il tipo di input in type=AssetTypes.URI_FILE.
Testo
```
{
    "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 i dati sono un file, usare invece il tipo UriFile per l'input.
Si noti che la variabile paths per il percorso viene aggiunta all'ID risorsa dell'archivio dati. Questo formato indica che il valore che segue è un percorso.

Suggerimento

È anche possibile usare il formato azureml://datastores/<data-store>/paths/<data-path> per specificare l'input.
Eseguire l'endpoint:
Usare l'argomento --set per specificare l'input:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_PATH
```
Per un endpoint che gestisce una distribuzione del modello, è possibile usare l'argomento --input per specificare l'input dei dati, perché una distribuzione del modello richiede sempre un solo input di dati.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_PATH --input-type uri_folder
```
L'argomento --set tende a produrre comandi lunghi quando vengono specificati diversi input. In questi casi, inserire gli input in un file YAML e usare l'argomento --file per specificare gli input necessari per la chiamata all'endpoint.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: azureml://datastores/<data-store>/paths/<data-path>
```
Esegui questo comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Se i dati sono un file, usare invece il tipo uri_file per l'input.
Suggerimento

Qual è la differenza tra il parametro inputs e input quando si richiama un endpoint?

In generale, è possibile usare un parametro inputs = {} del dizionario con il metodo invoke per fornire un numero arbitrario di input necessari a un endpoint batch che contiene una distribuzione modello o una distribuzione pipeline.

Per una distribuzione modello, è possibile usare il parametro input come modo più breve per specificare la posizione dei dati di input per la distribuzione. Questo approccio funziona perché una distribuzione del modello accetta sempre un solo input di dati.

Chiamare il metodo invoke usando il parametro inputs per specificare gli input necessari:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Semplificare ulteriormente la chiamata invoke per una distribuzione del modello usando il parametro inputper specificare il percorso per i dati di input:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Richiedi
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Usare i dati di input dagli account di Archiviazione di Azure

Gli endpoint batch di Azure Machine Learning possono leggere i dati dai percorsi cloud negli Account di archiviazione di Azure, sia pubblici che privati. Usare i passi seguenti per eseguire un processo di endpoint batch usando i dati archiviati in un account di archiviazione.

Per altre informazioni sulla configurazione aggiuntiva necessaria per la lettura dei dati dagli account di archiviazione, vedere Configurare i cluster di calcolo per l'accesso ai dati.

Creare l'input o la richiesta:

Impostare la variabile INPUT_DATA:

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

Se i dati sono un file, impostare la variabile con il formato seguente:

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

Impostare la variabile input:

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

Se i dati sono un file, modificare il tipo di input in type=AssetTypes.URI_FILE:

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

Testo

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

Se i dati sono un file, modificare il tipo di input in JobInputType:

Testo

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

Eseguire l'endpoint:
Usare l'argomento --set per specificare l'input:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_DATA
```
Per un endpoint che gestisce una distribuzione del modello, è possibile usare l'argomento --input per specificare l'input dei dati, perché una distribuzione del modello richiede sempre un solo input di dati.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_DATA --input-type uri_folder
```
L'argomento --set tende a produrre comandi lunghi quando vengono specificati diversi input. In questi casi, inserire gli input in un file YAML e usare l'argomento --file per specificare gli input necessari per la chiamata all'endpoint.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data
```
Esegui questo comando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Se i dati sono un file, usare invece il tipo uri_file per l'input.
Suggerimento

Qual è la differenza tra il parametro inputs e input quando si richiama un endpoint?

In generale, è possibile usare un parametro inputs = {} del dizionario con il metodo invoke per fornire un numero arbitrario di input necessari a un endpoint batch che contiene una distribuzione modello o una distribuzione pipeline.

Per una distribuzione modello, è possibile usare il parametro input come modo più breve per specificare la posizione dei dati di input per la distribuzione. Questo approccio funziona perché una distribuzione del modello accetta sempre un solo input di dati.

Chiamare il metodo invoke usando il parametro inputs per specificare gli input necessari:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Semplificare ulteriormente la chiamata invoke per una distribuzione del modello usando il parametro inputper specificare il percorso per i dati di input:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Richiedi
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Creare processi con input letterali

Le distribuzioni dei componenti della pipeline possono accettare input letterali. Nell'esempio seguente viene illustrato come specificare un input denominato score_mode, di tipo string, con un valore append:

Inserire gli input in un file YAML e usare --file per specificare gli input necessari per la chiamata all'endpoint.

inputs.yml

inputs:
  score_mode:
    type: string
    default: append

Esegui questo comando:

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

È anche possibile usare l'argomento --set per specificare il valore. Tuttavia, questo approccio tende a produrre comandi lunghi quando vengono specificati più input:

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

Testo

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

Richiedi

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

Creare processi con output di dati

Nell'esempio seguente viene illustrato come modificare il percorso in cui viene inserito un output denominato score. Ai fini della completezza, questi esempi configurano anche un input denominato heart_dataset.

Salvare l'output usando l'archivio dati predefinito nell'area di lavoro di Azure Machine Learning. È possibile usare qualsiasi altro archivio dati nell'area di lavoro, purché si tratti di un account di archiviazione BLOB.
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
L'ID degli archivi dati è simile a /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Usare l'interfaccia della riga di comando di Azure Machine Learning, Azure Machine Learning SDK per Python, o Studio per ottenere le informazioni sull'archivio dati.

Creare un output dei dati:

Impostare la variabile OUTPUT_PATH:

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

Ai fini della completezza, creare anche un input di dati:

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

Impostare la variabile path output:

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

Ai fini della completezza, creiamo anche un input di dati:

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

Testo

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

Si noti che la variabile paths per il percorso viene aggiunta all'ID risorsa dell'archivio dati. Questo formato indica che il valore che segue è un percorso.

Eseguire la distribuzione:

Usare l'argomento --set per specificare l'input:

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

Richiedi

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

Condividi tramite

Creare processi e inserire dati negli endpoint batch

Prerequisiti

Nozioni di base sulla creazione di processi

Richiamare una distribuzione specifica

Configurare le proprietà del processo

Configurare il nome dell'esperimento

Spiegare input e output

Esplorare gli input dei dati

Esplorare gli input letterali

Esplorare gli output dei dati

Creare processi con input di dati

Usare i dati di input dall'asset di dati

Usare i dati di input dagli archivi dati

Usare i dati di input dagli account di Archiviazione di Azure

Creare processi con input letterali

Creare processi con output di dati

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Creare processi e inserire dati negli endpoint batch

Prerequisiti

Nozioni di base sulla creazione di processi

Richiamare una distribuzione specifica

Configurare le proprietà del processo

Configurare il nome dell'esperimento

Spiegare input e output

Esplorare gli input dei dati

Esplorare gli input letterali

Esplorare gli output dei dati

Creare processi con input di dati

Usare i dati di input dall'asset di dati

Usare i dati di input dagli archivi dati

Usare i dati di input dagli account di Archiviazione di Azure

Creare processi con input letterali

Creare processi con output di dati

Contenuto correlato

Commenti e suggerimenti

Risorse aggiuntive