Distribuera befintliga pipelinejobb till batchslutpunkter

Artikel
09/01/2024

GÄLLER FÖR:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (aktuell)

Med Batch-slutpunkter kan du distribuera pipelinekomponenter, vilket ger ett bekvämt sätt att operationalisera pipelines i Azure Mašinsko učenje. Batch-slutpunkter accepterar pipelinekomponenter för distribution. Men om du redan har ett pipelinejobb som körs kan Azure Mašinsko učenje acceptera jobbet som indata till batchslutpunkten och skapa pipelinekomponenten automatiskt åt dig. I den här artikeln får du lära dig hur du använder ditt befintliga pipelinejobb som indata för batchdistribution.

Du lär dig att:

Kör och skapa det pipelinejobb som du vill distribuera
Skapa en batchdistribution från det befintliga jobbet
Testa distributionen

Om det här exemplet

I det här exemplet ska vi distribuera en pipeline som består av ett enkelt kommandojobb som skriver ut "hello world!". I stället för att registrera pipelinekomponenten före distributionen anger vi ett befintligt pipelinejobb som ska användas för distribution. Azure Mašinsko učenje skapar sedan pipelinekomponenten automatiskt och distribuerar den som en distribution av en batchslutpunktspipelinekomponent.

Exemplet i den här artikeln baseras på kodexempel som finns på lagringsplatsen azureml-examples . Om du vill köra kommandona lokalt utan att behöva kopiera/klistra in YAML och andra filer klonar du först lagringsplatsen och ändrar sedan kataloger till mappen:

Azure CLI
Python

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python

Filerna för det här exemplet finns i:

cd endpoints/batch/deploy-pipelines/hello-batch

Förutsättningar

En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Mašinsko učenje.
En Azure Machine Learning-arbetsyta. Information om hur du skapar en arbetsyta finns i Hantera Azure Mašinsko učenje-arbetsytor.
Kontrollera att du har följande behörigheter på Mašinsko učenje-arbetsytan:
- Skapa eller hantera batchslutpunkter och distributioner: Använd en ägare, deltagare eller anpassad roll som tillåter Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Skapa Azure Resource Manager-distributioner i arbetsytans resursgrupp: Använd en roll som ägare, deltagare eller anpassad som tillåter Microsoft.Resources/deployments/write i den resursgrupp där arbetsytan distribueras.
Installera följande programvara för att arbeta med Mašinsko učenje:
- Azure CLI
- Python
Kör följande kommando för att installera Azure CLI och ml tillägget för Azure Mašinsko učenje:
```
az extension add -n ml
```
Distributioner av pipelinekomponenter för Batch-slutpunkter introduceras i version 2.7 av ml tillägget för Azure CLI. az extension update --name ml Använd kommandot för att hämta den senaste versionen.
Kör följande kommando för att installera Azure Mašinsko učenje SDK för Python:
```
pip install azure-ai-ml
```
Klasserna ModelBatchDeployment och PipelineComponentBatchDeployment introduceras i version 1.7.0 av SDK:et. pip install -U azure-ai-ml Använd kommandot för att hämta den senaste versionen.

Anslut till din arbetsyta

Arbetsytan är resursen på den översta nivån för Mašinsko učenje. Den ger en central plats där du kan arbeta med alla artefakter som du skapar när du använder Mašinsko učenje. I det här avsnittet ansluter du till arbetsytan där du utför dina distributionsuppgifter.

Azure CLI
Python

I följande kommando anger du värdena för ditt prenumerations-ID, arbetsyta, plats och resursgrupp:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Importera de bibliotek som krävs:

from azure.ai.ml import MLClient, Input, load_component
from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
from azure.ai.ml.dsl import pipeline
from azure.identity import DefaultAzureCredential

Konfigurera arbetsytans information och få ett handtag till arbetsytan:

I följande kommando anger du värdena för ditt prenumerations-ID, arbetsyta och resursgrupp:

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

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Kör pipelinejobbet som du vill distribuera

I det här avsnittet börjar vi med att köra ett pipelinejobb:

Azure CLI
Python

Följande pipeline-job.yml fil innehåller konfigurationen för pipelinejobbet:

pipeline-job.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

experiment_name: hello-pipeline-batch
display_name: hello-pipeline-batch-job
description: This job demonstrates how to run the a pipeline component in a pipeline job. You can use this example to test a component in an standalone job before deploying it in an endpoint.

compute: batch-cluster
component: hello-component/hello.yml

Läs in pipelinekomponenten och instansiera den:

hello_batch = load_component(source="hello-component/hello.yml")
pipeline_job = hello_batch()

Konfigurera nu vissa körningsinställningar för att köra testet. Den här artikeln förutsätter att du har ett beräkningskluster med namnet batch-cluster. Du kan ersätta klustret med namnet på ditt.

pipeline_job.settings.default_compute = "batch-cluster"
pipeline_job.settings.default_datastore = "workspaceblobstore"

Skapa pipelinejobbet:

Azure CLI
Python

JOB_NAME=$(az ml job create -f pipeline-job.yml --query name -o tsv)

pipeline_job_run = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="hello-batch-pipeline"
)
pipeline_job_run

Skapa en batchslutpunkt

Innan vi distribuerar pipelinejobbet måste vi distribuera en batchslutpunkt som värd för distributionen.

Ange ett namn för slutpunkten. Namnet på en batchslutpunkt måste vara unikt i varje region eftersom namnet används för att konstruera anrops-URI:n. För att säkerställa unikhet lägger du till eventuella avslutande tecken i det namn som anges i följande kod.
- Azure CLI
- Python
```
ENDPOINT_NAME="hello-batch"
```
```
endpoint_name="hello-batch"
```

Konfigurera slutpunkten:

Azure CLI
Python

Filen endpoint.yml innehåller slutpunktens konfiguration.

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: hello-batch
description: A hello world endpoint for component deployments.
auth_mode: aad_token

endpoint = BatchEndpoint(
    name=endpoint_name,
    description="A hello world endpoint for component deployments",
)

Skapa slutpunkten:

Azure CLI
Python

az ml batch-endpoint create --name $ENDPOINT_NAME  -f endpoint.yml

ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

Fråga slutpunkts-URI:n:

Azure CLI
Python

az ml batch-endpoint show --name $ENDPOINT_NAME

endpoint = ml_client.batch_endpoints.get(name=endpoint_name)
print(endpoint)

Distribuera pipelinejobbet

För att distribuera pipelinekomponenten måste vi skapa en batchdistribution från det befintliga jobbet.

Vi måste berätta för Azure Mašinsko učenje namnet på det jobb som vi vill distribuera. I vårt fall anges det jobbet i följande variabel:
- Azure CLI
- Python
```
echo $JOB_NAME
```
```
print(job.name)
```

Konfigurera distributionen.

Azure CLI
Python

Filen deployment-from-job.yml innehåller distributionens konfiguration. Observera hur vi använder nyckeln job_definition i stället för component för att ange att den här distributionen skapas från ett pipelinejobb:

deployment-from-job.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
name: hello-batch-from-job
endpoint_name: hello-pipeline-batch
type: pipeline
job_definition: azureml:job_name_placeholder
settings:
    continue_on_step_failure: false
    default_compute: batch-cluster

Observera nu hur vi använder egenskapen job_definition i stället componentför :

deployment = PipelineComponentBatchDeployment(
    name="hello-batch-from-job",
    description="A hello world deployment with a single step. This deployment is created from a pipeline job.",
    endpoint_name=endpoint.name,
    job_definition=pipeline_job_run,
    settings={
        "default_compute": "batch-cluster",
        "continue_on_step_failure": False
    }
)

Dricks

Den här konfigurationen förutsätter att du har ett beräkningskluster med namnet batch-cluster. Du kan ersätta det här värdet med namnet på klustret.

Skapa distributionen:
- Azure CLI
- Python
Kör följande kod för att skapa en batchdistribution under batchslutpunkten och ange den som standarddistribution.
```
az ml batch-deployment create --endpoint $ENDPOINT_NAME --set job_definition=azureml:$JOB_NAME -f deployment-from-job.yml
```
Dricks

Observera användningen av --set job_definition=azureml:$JOB_NAME. Eftersom jobbnamnen är unika används kommandot --set här för att ändra namnet på jobbet när du kör det på arbetsytan.
Det här kommandot startar distributionen och returnerar ett bekräftelsesvar medan distributionen fortsätter.
```
ml_client.batch_deployments.begin_create_or_update(deployment).result()
```
När vi har skapat den här nya distributionen ska vi konfigurera den som standard:
```
endpoint = ml_client.batch_endpoints.get(endpoint.name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
Distributionen är klar för användning.

Testa distributionen

När distributionen har skapats är den redo att ta emot jobb. Du kan anropa standarddistributionen på följande sätt:

Azure CLI
Python

JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --query name -o tsv)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, 
)

Du kan övervaka förloppet för showen och strömma loggarna med hjälp av:

Azure CLI
Python

az ml job stream -n $JOB_NAME

ml_client.jobs.get(name=job.name)

Kör följande kod för att vänta tills jobbet har slutförts:

ml_client.jobs.stream(name=job.name)

Rensa resurser

När du är klar tar du bort de associerade resurserna från arbetsytan:

Azure CLI
Python

Kör följande kod för att ta bort batchslutpunkten och dess underliggande distribution. --yes används för att bekräfta borttagningen.

az ml batch-endpoint delete -n $ENDPOINT_NAME --yes

Ta bort slutpunkten:

ml_client.batch_endpoints.begin_delete(endpoint.name).result()

Dela via