Skapa jobb och indata för batchslutpunkter

Artikel
09/01/2024

Med Batch-slutpunkter kan du utföra långa batchåtgärder över stora mängder data. Data kan finnas på olika platser, till exempel i spridningsregioner. Vissa typer av batchslutpunkter kan också ta emot literalparametrar som indata.

Den här artikeln beskriver hur du anger parameterindata för batchslutpunkter och skapar distributionsjobb. Processen stöder arbete med olika typer av data. Några exempel finns i Förstå indata och utdata.

Förutsättningar

Om du vill anropa en batchslutpunkt och skapa jobb kontrollerar du att du uppfyller följande krav:

En batchslutpunkt och distribution. Om du inte har dessa resurser kan du läsa Distribuera modeller för bedömning i batchslutpunkter för att skapa en distribution.
Behörigheter för att köra en batchslutpunktsdistribution. AzureML-roller för dataforskare, deltagare och ägare kan användas för att köra en distribution. Anpassade rolldefinitioner finns i Auktorisering på batchslutpunkter för att granska de specifika behörigheter som krävs.
En giltig Microsoft Entra-ID-token som representerar ett säkerhetsobjekt för att anropa slutpunkten. Det här huvudkontot kan vara användarens huvudnamn eller tjänstens huvudnamn. När du har anropat en slutpunkt skapar Azure Mašinsko učenje ett batchdistributionsjobb under den identitet som är associerad med token. Du kan använda dina egna autentiseringsuppgifter för anropet enligt beskrivningen i följande procedurer.
- Azure CLI
- Python
- REST
Använd Azure CLI för att logga in med interaktiv kod eller enhetskodautentisering :
```
az login
```
Använd Azure Mašinsko učenje SDK för Python för att logga in:
```
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

ml_client = MLClient.from_config(DefaultAzureCredential())
```
Om konfigurationen körs utanför en Azure-Mašinsko učenje beräkning måste du ange den arbetsyta där slutpunkten distribueras:
```
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)
```
Det enklaste sättet att få en giltig token för ditt användarkonto är att använda Azure CLI. Kör följande Azure CLI-kommando i en konsol:
```
az account get-access-token --resource https://ml.azure.com --query "accessToken" --output tsv
```
Dricks

När du arbetar med REST rekommenderar vi att du anropar batchslutpunkter med hjälp av tjänstens huvudnamn. Mer information finns i Köra jobb med hjälp av tjänstens huvudnamn (REST) för att lära dig hur du hämtar en token för ett tjänsthuvudnamn med REST.
Mer information om hur du startar batchdistributionsjobb med hjälp av olika typer av autentiseringsuppgifter finns i Så här kör du jobb med olika typer av autentiseringsuppgifter.
Beräkningsklustret där slutpunkten distribueras har åtkomst till att läsa indata.

Dricks

Om du använder ett datalager utan autentiseringsuppgifter eller ett externt Azure Storage-konto som indata kontrollerar du att du konfigurerar beräkningskluster för dataåtkomst. Den hanterade identiteten för beräkningsklustret används för att montera lagringskontot. Jobbets identitet (anroparen) används fortfarande för att läsa underliggande data, vilket gör att du kan uppnå detaljerad åtkomstkontroll.

Skapa grunderna för jobb

Om du vill skapa ett jobb från en batchslutpunkt anropar du slutpunkten. Anrop kan göras med hjälp av Azure CLI, Azure Mašinsko učenje SDK för Python eller ett REST API-anrop. I följande exempel visas grunderna för anrop för en batchslutpunkt som tar emot en enda indatamapp för bearbetning. Exempel med olika indata och utdata finns i Förstå indata och utdata.

Använd åtgärden invoke under batchslutpunkter:

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

MLClient.batch_endpoints.invoke() Använd metoden för att ange namnet på experimentet:

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

Skicka en POST begäran till slutpunktens anrops-URL. Du kan hämta anrops-URL:en från Azure Mašinsko učenje-portalen på slutpunktens informationssida.

Brödtext

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

Begär

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

Anropa en specifik distribution

Batch-slutpunkter kan vara värdar för flera distributioner under samma slutpunkt. Standardslutpunkten används, såvida inte användaren anger något annat. Du kan ändra distributionen så att den används med följande procedurer.

Använd argumentet --deployment-name eller -d för att ange namnet på distributionen:

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

Använd parametern deployment_name för att ange namnet på distributionen:

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

Lägg till huvudet azureml-model-deployment i din begäran, inklusive namnet på den distribution som du vill anropa:

Brödtext

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

Begär

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

Konfigurera jobbegenskaper

Du kan konfigurera några av egenskaperna i det skapade jobbet vid anropstillfället.

Kommentar

Möjligheten att konfigurera jobbegenskaper är för närvarande endast tillgänglig i batchslutpunkter med pipelinekomponentdistributioner.

Konfigurera experimentnamnet

Använd följande procedurer för att konfigurera experimentnamnet.

Använd argumentet --experiment-name för att ange namnet på experimentet:

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

Använd parametern experiment_name för att ange namnet på experimentet:

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

Ange experimentnamnet med hjälp experimentName av nyckeln i avsnittet properties :

Brödtext

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

Begär

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

Förstå indata och utdata

Batch-slutpunkter tillhandahåller ett beständiga API som konsumenterna kan använda för att skapa batchjobb. Samma gränssnitt kan användas för att ange indata och utdata som distributionen förväntar sig. Använd indata för att skicka all information som slutpunkten behöver för att utföra jobbet.

Diagram som visar hur indata och utdata används i batchslutpunkter.

Batch-slutpunkter stöder två typer av indata:

Dataindata: Pekare till en specifik lagringsplats eller Azure Mašinsko učenje tillgång.
Literala indata: Literala värden som tal eller strängar som du vill skicka till jobbet.

Antalet och typen av indata och utdata beror på typen av batchdistribution. Modelldistributioner kräver alltid en datainmatning och skapar ett datautdata. Literala indata stöds inte. Distributioner av pipelinekomponenter ger dock en mer allmän konstruktion för att skapa slutpunkter och gör att du kan ange valfritt antal indata (data och literal) och utdata.

I följande tabell sammanfattas indata och utdata för batchdistributioner:

Distributionstyp	Antal indata	Indatatyper som stöds	Antal utdata	Utdatatyper som stöds
Modelldistribution	1	Dataindata	1	Datautdata
Distribution av pipelinekomponenter	[0..N]	Indata och literala indata	[0..N]	Datautdata

Dricks

Indata och utdata namnges alltid. Namnen fungerar som nycklar för att identifiera data och skicka det faktiska värdet under anropet. Eftersom modelldistributioner alltid kräver en in- och utdata ignoreras namnet under anropet. Du kan tilldela det namn som bäst beskriver ditt användningsfall, till exempel "sales_estimation".

Utforska dataindata

Dataindata refererar till indata som pekar på en plats där data placeras. Eftersom batchslutpunkter vanligtvis förbrukar stora mängder data kan du inte skicka indata som en del av begäran om anrop. I stället anger du den plats där batchslutpunkten ska gå för att leta efter data. Indata monteras och strömmas på målberäkningen för att förbättra prestandan.

Batch-slutpunkter stöder läsning av filer som finns i följande lagringsalternativ:

Azure Mašinsko učenje datatillgångar, inklusive Mapp (uri_folder) och Fil (uri_file).
Azure Mašinsko učenje datalager, inklusive Azure Blob Storage, Azure Data Lake Storage Gen1 och Azure Data Lake Storage Gen2.
Azure Storage-konton, inklusive Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2 och Azure Blob Storage.
Lokala datamappar/filer (Azure Mašinsko učenje CLI eller Azure Mašinsko učenje SDK för Python). Den åtgärden resulterar dock i att lokala data laddas upp till standard-Azure Mašinsko učenje Data Store för arbetsytan som du arbetar med.

Viktigt!

Utfasningsmeddelande: Datauppsättningar av typen FileDataset (V1) är inaktuella och kommer att dras tillbaka i framtiden. Befintliga batchslutpunkter som förlitar sig på den här funktionen fortsätter att fungera. Batchslutpunkter som skapats med GA CLIv2 (2.4.0 och senare) eller GA REST API (2022-05-01 och senare) stöder inte V1-datauppsättning.

Utforska literalindata

Literala indata refererar till indata som kan representeras och matchas vid anrop, till exempel strängar, tal och booleska värden. Du använder vanligtvis literala indata för att skicka parametrar till slutpunkten som en del av en pipelinekomponentdistribution. Batch-slutpunkter stöder följande literaltyper:

string
boolean
float
integer

Literala indata stöds endast i pipelinekomponentdistributioner. Se Skapa jobb med literala indata för att lära dig hur du anger dem.

Utforska datautdata

Datautdata refererar till den plats där resultatet av ett batchjobb ska placeras. Varje utdata har ett identifierbart namn och Azure Mašinsko učenje tilldelar automatiskt en unik sökväg till varje namngiven utdata. Du kan ange en annan sökväg efter behov.

Viktigt!

Batch-slutpunkter har endast stöd för att skriva utdata i Azure Blob Storage-datalager. Om du behöver skriva till ett lagringskonto med hierarkiska namnområden aktiverade (kallas även Azure Datalake Gen2 eller ADLS Gen2) kan du registrera lagringstjänsten som ett Azure Blob Storage-datalager eftersom tjänsterna är helt kompatibla. På så sätt kan du skriva utdata från batchslutpunkter till ADLS Gen2.

Skapa jobb med dataindata

I följande exempel visas hur du skapar jobb, tar dataindata från datatillgångar, datalager och Azure Storage-konton.

Använda indata från datatillgång

Azure Mašinsko učenje datatillgångar (tidigare kallade datauppsättningar) stöds som indata för jobb. Följ de här stegen för att köra ett batchslutpunktsjobb med hjälp av data som lagras i en registrerad datatillgång i Azure Mašinsko učenje.

Varning

Datatillgångar av typen Tabell (MLTable) stöds för närvarande inte.

Skapa först datatillgången. Den här datatillgången består av en mapp med flera CSV-filer som du bearbetar parallellt med hjälp av batchslutpunkter. Du kan hoppa över det här steget om dina data redan är registrerade som en datatillgång.
- Azure CLI
- Python
- REST
Skapa en datatillgångsdefinition i 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
```
Skapa sedan datatillgången:
```
az ml data create -f heart-dataset-unlabeled.yml
```
Skapa en definition av datatillgång:
```
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,
)
```
Skapa datatillgången:
```
ml_client.data.create_or_update(heart_dataset_unlabeled)
```
Använd följande kommando för att hämta den nyligen skapade datatillgången:
```
heart_dataset_unlabeled = ml_client.data.get(name=dataset_name, label="latest")
```
Använd Azure Mašinsko učenje CLI, Azure Mašinsko učenje SDK för Python eller Azure Mašinsko učenje Studio för att hämta plats (region), arbetsyta och datatillgångsnamn och version. Du behöver dessa objekt för senare procedurer.

Skapa indata eller begäran:

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

input = Input(path=heart_dataset_unlabeled.id)

Brödtext

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

Datatillgångarnas ID ser ut som /subscriptions/<subscription>/resourcegroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/data/<data-asset>/versions/<version>. Du kan också använda azureml:<datasset_name>@latest formatet för att ange indata.

Kör slutpunkten:
- Azure CLI
- Python
- REST
--set Använd argumentet för att ange indata:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$DATASET_ID
```
För en slutpunkt som hanterar en modelldistribution kan du använda --input argumentet för att ange indata eftersom en modelldistribution alltid bara kräver en datainmatning.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $DATASET_ID
```
Argumentet --set tenderar att generera långa kommandon när flera indata anges. I sådana fall placerar du dina indata i en YAML fil och använder --file argumentet för att ange de indata som du behöver för slutpunktsanropet.

inputs.yml
```
inputs:
  heart_dataset: azureml:/<datasset_name>@latest
```
Kör följande kommando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Dricks

Vad är skillnaden mellan parametern inputs och input när du anropar en slutpunkt?

I allmänhet kan du använda en ordlisteparameter inputs = {} med invoke metoden för att ange ett godtyckligt antal obligatoriska indata till en batchslutpunkt som innehåller en modelldistribution eller en pipelinedistribution.

För en modelldistribution kan du använda parametern input som ett kortare sätt att ange indataplatsen för distributionen. Den här metoden fungerar eftersom en modelldistribution alltid bara tar en datainmatning.

invoke Anropa metoden med hjälp av parametern inputs för att ange nödvändiga indata:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Förenkla anropet invoke för en modelldistribution ytterligare med hjälp av parametern input för att ange platsen för indata:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Begär
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Använda indata från datalager

Du kan direkt referera till data från Azure Mašinsko učenje registrerade datalager med batchdistributionsjobb. I det här exemplet laddar du först upp vissa data till standarddatalagret i Azure Mašinsko učenje-arbetsytan och kör sedan en batchdistribution på den. Följ de här stegen för att köra ett batchslutpunktsjobb med data som lagras i ett datalager.

Få åtkomst till standarddatalagret i Azure Mašinsko učenje-arbetsytan. Om dina data finns i ett annat lager kan du använda det arkivet i stället. Du behöver inte använda standarddatalagret.
- Azure CLI
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
Datalager-ID:t ser ut som /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Använd Azure Mašinsko učenje CLI, Azure Mašinsko učenje SDK för Python eller studion för att hämta information om datalagret.
Dricks

Standardlagringen av blobdata i en arbetsyta heter workspaceblobstore. Du kan hoppa över det här steget om du redan känner till resurs-ID:t för standarddatalagret på din arbetsyta.
Ladda upp exempeldata till datalagret.

Det här exemplet förutsätter att du redan har laddat upp exempeldata som ingår i lagringsplatsen i mappen sdk/python/endpoints/batch/deploy-models/heart-classifier-mlflow/data i mappen heart-disease-uci-unlabeled i Blob Storage-kontot. Var noga med att slutföra det här steget innan du fortsätter.

Skapa indata eller begäran:

Placera filsökvägen i variabeln INPUT_PATH :

DATA_PATH="heart-disease-uci-unlabeled"
INPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"

Placera filsökvägen i variabeln input :

data_path = "heart-disease-uci-unlabeled"
input = Input(type=AssetTypes.URI_FOLDER, path=f"{default_ds.id}/paths/{data_path})

Om dina data är en fil ändrar du indatatypen till type=AssetTypes.URI_FILE.

Brödtext

{
    "properties": {
        "InputData": {
            "heart_dataset": {
                "JobInputType" : "UriFolder",
                "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
            }
        }
    }
}

Om dina data är en fil använder du UriFile typen för indata i stället.

Observera hur variabeln paths för sökvägen läggs till i resurs-ID:t för datalagret. Det här formatet anger att värdet som följer är en sökväg.

Dricks

Du kan också använda formatet azureml://datastores/<data-store>/paths/<data-path> för att ange indata.

Kör slutpunkten:
- Azure CLI
- Python
- REST
--set Använd argumentet för att ange indata:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_PATH
```
För en slutpunkt som hanterar en modelldistribution kan du använda --input argumentet för att ange indata eftersom en modelldistribution alltid bara kräver en datainmatning.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_PATH --input-type uri_folder
```
Argumentet --set tenderar att generera långa kommandon när flera indata anges. I sådana fall placerar du dina indata i en YAML fil och använder --file argumentet för att ange de indata som du behöver för slutpunktsanropet.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: azureml://datastores/<data-store>/paths/<data-path>
```
Kör följande kommando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Om dina data är en fil använder du uri_file typen för indata i stället.
Dricks

Vad är skillnaden mellan parametern inputs och input när du anropar en slutpunkt?

I allmänhet kan du använda en ordlisteparameter inputs = {} med invoke metoden för att ange ett godtyckligt antal obligatoriska indata till en batchslutpunkt som innehåller en modelldistribution eller en pipelinedistribution.

För en modelldistribution kan du använda parametern input som ett kortare sätt att ange indataplatsen för distributionen. Den här metoden fungerar eftersom en modelldistribution alltid bara tar en datainmatning.

invoke Anropa metoden med hjälp av parametern inputs för att ange nödvändiga indata:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Förenkla anropet invoke för en modelldistribution ytterligare med hjälp av parametern input för att ange platsen för indata:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Begär
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Använda indata från Azure Storage-konton

Azure Mašinsko učenje batchslutpunkter kan läsa data från molnplatser i Azure Storage-konton, både offentliga och privata. Använd följande steg för att köra ett batchslutpunktsjobb med data som lagras i ett lagringskonto.

Mer information om extra konfiguration som krävs för att läsa data från lagringskonton finns i Konfigurera beräkningskluster för dataåtkomst.

Skapa indata eller begäran:

Ange variabeln INPUT_DATA :

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

Om dina data är en fil anger du variabeln med följande format:

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

Ange variabeln input :

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

Om dina data är en fil ändrar du indatatypen till type=AssetTypes.URI_FILE:

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

Brödtext

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

Om dina data är en fil ändrar du indatatypen till JobInputType:

Brödtext

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

Kör slutpunkten:
- Azure CLI
- Python
- REST
--set Använd argumentet för att ange indata:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_DATA
```
För en slutpunkt som hanterar en modelldistribution kan du använda --input argumentet för att ange indata eftersom en modelldistribution alltid bara kräver en datainmatning.
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_DATA --input-type uri_folder
```
Argumentet --set tenderar att generera långa kommandon när flera indata anges. I sådana fall placerar du dina indata i en YAML fil och använder --file argumentet för att ange de indata som du behöver för slutpunktsanropet.

inputs.yml
```
inputs:
  heart_dataset:
    type: uri_folder
    path: https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data
```
Kör följande kommando:
```
az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
```
Om dina data är en fil använder du uri_file typen för indata i stället.
Dricks

Vad är skillnaden mellan parametern inputs och input när du anropar en slutpunkt?

I allmänhet kan du använda en ordlisteparameter inputs = {} med invoke metoden för att ange ett godtyckligt antal obligatoriska indata till en batchslutpunkt som innehåller en modelldistribution eller en pipelinedistribution.

För en modelldistribution kan du använda parametern input som ett kortare sätt att ange indataplatsen för distributionen. Den här metoden fungerar eftersom en modelldistribution alltid bara tar en datainmatning.

invoke Anropa metoden med hjälp av parametern inputs för att ange nödvändiga indata:
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": input,
    }
)
```
Förenkla anropet invoke för en modelldistribution ytterligare med hjälp av parametern input för att ange platsen för indata:
```
job = ml_client.batch_endpoints.invoke(
   endpoint_name=endpoint.name,
   input=input,
)
```
Begär
```
POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
```

Skapa jobb med literala indata

Distributioner av pipelinekomponenter kan ta literala indata. I följande exempel visas hur du anger en indata med namnet score_mode, av typen string, med värdet append:

Placera dina indata i en YAML fil och använd --file för att ange de indata som du behöver för slutpunktsanropet.

inputs.yml

inputs:
  score_mode:
    type: string
    default: append

Kör följande kommando:

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

Du kan också använda --set argumentet för att ange värdet. Den här metoden tenderar dock att generera långa kommandon när flera indata anges:

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

Brödtext

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

Begär

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

Skapa jobb med datautdata

I följande exempel visas hur du ändrar platsen där utdata med namnet score placeras. För fullständighet konfigurerar de här exemplen även indata med namnet heart_dataset.

Spara utdata med hjälp av standarddatalagret i Azure Mašinsko učenje-arbetsytan. Du kan använda alla andra datalager på din arbetsyta så länge det är ett Blob Storage-konto.
- Azure CLI
- Python
- REST
```
DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
```
Datalager-ID:t ser ut som /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.
```
default_ds = ml_client.datastores.get_default()
```
Använd Azure Mašinsko učenje CLI, Azure Mašinsko učenje SDK för Python eller studion för att hämta information om datalagret.

Skapa ett datautdata:

Ange variabeln OUTPUT_PATH :

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

Skapa även dataindata för fullständighet:

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

Ange sökvägsvariabeln output :

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

För fullständighet ska vi också skapa en datainmatning:

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

Brödtext

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

Kommentar

Observera hur variabeln paths för sökvägen läggs till i resurs-ID:t för datalagret. Det här formatet anger att värdet som följer är en sökväg.

Kör distributionen:

--set Använd argumentet för att ange indata:

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

Begär

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

Dela via

Skapa jobb och indata för batchslutpunkter

Förutsättningar

Skapa grunderna för jobb

Anropa en specifik distribution

Konfigurera jobbegenskaper

Konfigurera experimentnamnet

Förstå indata och utdata

Utforska dataindata

Utforska literalindata

Utforska datautdata

Skapa jobb med dataindata

Använda indata från datatillgång

Använda indata från datalager

Använda indata från Azure Storage-konton

Skapa jobb med literala indata

Skapa jobb med datautdata

Feedback

Ytterligare resurser

Dela via

Skapa jobb och indata för batchslutpunkter

Förutsättningar

Skapa grunderna för jobb

Anropa en specifik distribution

Konfigurera jobbegenskaper

Konfigurera experimentnamnet

Förstå indata och utdata

Utforska dataindata

Utforska literalindata

Utforska datautdata

Skapa jobb med dataindata

Använda indata från datatillgång

Använda indata från datalager

Använda indata från Azure Storage-konton

Skapa jobb med literala indata

Skapa jobb med datautdata

Relaterat innehåll

Feedback

Ytterligare resurser