Så här operationaliserar du en träningspipeline med batchslutpunkter

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

I den här artikeln får du lära dig hur du operationaliserar en träningspipeline under en batchslutpunkt. Pipelinen använder flera komponenter (eller steg) som omfattar modellträning, förbearbetning av data och modellutvärdering.

Du lär dig att:

• Skapa och testa en träningspipeline
• Distribuera pipelinen till en batchslutpunkt
• Ändra pipelinen och skapa en ny distribution i samma slutpunkt
• Testa den nya distributionen och ange den som standarddistribution

Om det här exemplet

Det här exemplet distribuerar en träningspipeline som tar indataträningsdata (märkta) och skapar en förutsägelsemodell, tillsammans med utvärderingsresultaten och de omvandlingar som tillämpas under förbearbetningen. Pipelinen använder tabelldata från UCI Heart Disease Data Set för att träna en XGBoost-modell. Vi använder en dataförbearbetningskomponent för att förbearbeta data innan de skickas till träningskomponenten för att anpassa och utvärdera modellen.

En visualisering av pipelinen är följande:

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

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

Python

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/training-with-components

Följ med i Jupyter Notebooks

Du kan följa med i Python SDK-versionen av det här exemplet genom att öppna notebook-filen sdk-deploy-and-test.ipynb på den klonade lagringsplatsen.

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

  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.

  Python

  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

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>

Python

1. 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
   

2. 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)
   

Skapa träningspipelinekomponenten

I det här avsnittet skapar vi alla tillgångar som krävs för vår träningspipeline. Vi börjar med att skapa en miljö som innehåller nödvändiga bibliotek för att träna modellen. Sedan skapar vi ett beräkningskluster som batchdistributionen ska köras på, och slutligen registrerar vi indata som en datatillgång.

Skapa miljön

Komponenterna i det här exemplet använder en miljö med biblioteken XGBoost och scikit-learn . Filen environment/conda.yml innehåller miljöns konfiguration:

miljö/conda.yml

channels:
- conda-forge
dependencies:
- python=3.8.5
- pip
- pip:
  - mlflow
  - azureml-mlflow
  - datasets
  - jobtools
  - cloudpickle==1.6.0
  - dask==2023.2.0
  - scikit-learn==1.1.2
  - xgboost==1.3.3
  - pandas==1.4
name: mlflow-env

Skapa miljön på följande sätt:

1. Definiera miljön:

   Azure CLI

   miljö/xgboost-sklearn-py38.yml

   $schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
   name: xgboost-sklearn-py38
   image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
   conda_file: conda.yml
   description: An environment for models built with XGBoost and Scikit-learn.
   

   Python

   environment = Environment(
       name="xgboost-sklearn-py38",
       description="An environment for models built with XGBoost and Scikit-learn.",
       image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
       conda_file="environment/conda.yml",
   )

2. Skapa miljön:

   Azure CLI

   az ml environment create -f environment/xgboost-sklearn-py38.yml
   

   Python

   try:
       ml_client.environments.create_or_update(environment)
   except ResourceExistsError:
       pass

Skapa ett beräkningskluster

Batchslutpunkter och distributioner körs på beräkningskluster. De kan köras på valfritt Azure-Mašinsko učenje beräkningskluster som redan finns på arbetsytan. Därför kan flera batchdistributioner dela samma beräkningsinfrastruktur. I det här exemplet ska vi arbeta med ett Azure Mašinsko učenje beräkningskluster med namnet batch-cluster. Nu ska vi kontrollera att beräkningen finns på arbetsytan eller skapa den på annat sätt.

Azure CLI

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Python

compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="Batch endpoints compute cluster",
        min_instances=0,
        max_instances=5,
    )
    ml_client.begin_create_or_update(compute_cluster).result()

Registrera träningsdata som en datatillgång

Våra träningsdata representeras i CSV-filer. För att efterlikna en mer arbetsbelastning på produktionsnivå ska vi registrera träningsdata i heart.csv filen som en datatillgång på arbetsytan. Den här datatillgången visas senare som indata till slutpunkten.

Azure CLI

az ml data create --name heart-classifier-train --type uri_folder --path data/train

Python

data_path = "data/train"
dataset_name = "heart-dataset-train"

heart_dataset_train = Data(
    path=data_path,
    type=AssetTypes.URI_FOLDER,
    description="A training dataset for heart classification",
    name=dataset_name,
)

Skapa datatillgången:

ml_client.data.create_or_update(heart_dataset_train)

Nu ska vi hämta en referens till den nya datatillgången:

heart_dataset_train = ml_client.data.get(name=dataset_name, label="latest")

Skapa pipelinen

Pipelinen som vi vill operationalisera tar en indata, träningsdata och genererar tre utdata: den tränade modellen, utvärderingsresultaten och de datatransformeringar som tillämpas som förbearbetning. Pipelinen består av två komponenter:

• preprocess_job: Det här steget läser indata och returnerar förberedda data och tillämpade transformeringar. Steget tar emot tre indata:
  • data: en mapp som innehåller indata för att transformera och poängsätta
  • transformations: (valfritt) Sökväg till de transformeringar som ska tillämpas, om det är tillgängligt. Om sökvägen inte tillhandahålls kommer omvandlingarna att läras från indata. Eftersom indata transformations är valfria kan komponenten preprocess_job användas under träning och bedömning.
  • categorical_encoding: kodningsstrategin för kategoriska funktioner (ordinal eller onehot).
• train_job: Det här steget tränar en XGBoost-modell baserat på förberedda data och returnerar utvärderingsresultaten och den tränade modellen. Steget tar emot tre indata:
  • data: förbearbetade data.
  • target_column: den kolumn som vi vill förutsäga.
  • eval_size: anger andelen indata som används för utvärdering.

Azure CLI

Pipelinekonfigurationen definieras i deployment-ordinal/pipeline.yml filen:

deployment-ordinal/pipeline.yml

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

name: uci-heart-train-pipeline
display_name: uci-heart-train
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

inputs:
  input_data:
    type: uri_folder

outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: ../components/prepare/prepare.yml
    inputs:
      data: ${{parent.inputs.input_data}}
      categorical_encoding: ordinal
    outputs:
      prepared_data:
      transformations_output: ${{parent.outputs.prepare_transformations}}
  
  train_job:
    type: command
    component: ../components/train_xgb/train_xgb.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      target_column: target
      register_best_model: false
      eval_size: 0.3
    outputs:
      model: 
        mode: upload
        type: mlflow_model
        path: ${{parent.outputs.model}}
      evaluation_results:
        mode: upload
        type: uri_folder
        path: ${{parent.outputs.evaluation_results}}

Kommentar

pipeline.yml I filen transformations saknas indata från preprocess_job. Därför lär sig skriptet transformeringsparametrarna från indata.

Python

Konfigurationerna för pipelinekomponenterna finns i prepare.yml filerna och train_xgb.yml . Läs in komponenterna:

prepare_data = load_component(source="components/prepare/prepare.yml")
train_xgb = load_component(source="components/train_xgb/train_xgb.yml")

Skapa pipelinen:

@pipeline()
def uci_heart_classifier_trainer(input_data: Input(type=AssetTypes.URI_FOLDER)):
    prepared_data = prepare_data(data=input_data)
    trained_model = train_xgb(
        data=prepared_data.outputs.prepared_data,
        target_column="target",
        register_best_model=False,
        eval_size=0.3,
    )

    return {
        "model": trained_model.outputs.model,
        "evaluation_results": trained_model.outputs.evaluation_results,
        "transformations_output": prepared_data.outputs.transformations_output,
    }

Kommentar

I pipelinen transformations saknas indata. Därför lär sig skriptet parametrarna från indata.

En visualisering av pipelinen är följande:

Testa pipelinen

Nu ska vi testa pipelinen med några exempeldata. För att göra det skapar vi ett jobb med hjälp av pipelinen och batch-cluster beräkningsklustret som skapades tidigare.

Azure CLI

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

deployment-ordinal/pipeline-job.yml

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

experiment_name: uci-heart-train-pipeline
display_name: uci-heart-train-job
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    mode: upload

Python

pipeline_job = uci_heart_classifier_trainer(
    Input(type="uri_folder", path=heart_dataset_train.id)
)

Nu ska vi konfigurera några körningsinställningar för att köra testet:

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

Skapa testjobbet:

Azure CLI

az ml job create -f deployment-ordinal/pipeline-job.yml --set inputs.input_data.path=azureml:heart-classifier-train@latest

Python

pipeline_job_run = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="uci-heart-train-pipeline"
)
pipeline_job_run

Skapa en batchslutpunkt

1. 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

   ENDPOINT_NAME="uci-classifier-train"
   

   Python

   endpoint_name = "uci-classifier-train"

2. Konfigurera slutpunkten:

   Azure CLI

   Filen endpoint.yml innehåller slutpunktens konfiguration.

   endpoint.yml

   $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
   name: uci-classifier-train
   description: An endpoint to perform training of the Heart Disease Data Set prediction task.
   auth_mode: aad_token
   

   Python

   endpoint = BatchEndpoint(
       name=endpoint_name,
       description="An endpoint to perform training of the Heart Disease Data Set prediction task",
   )

3. Skapa slutpunkten:

   Azure CLI

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

   Python

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

4. Fråga slutpunkts-URI:n:

   Azure CLI

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

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

Distribuera pipelinekomponenten

För att distribuera pipelinekomponenten måste vi skapa en batchdistribution. En distribution är en uppsättning resurser som krävs för att vara värd för den tillgång som utför det faktiska arbetet.

1. Konfigurera distributionen:

   Azure CLI

   Filen deployment-ordinal/deployment.yml innehåller distributionens konfiguration. Du kan kontrollera YAML-schemat för den fullständiga batchslutpunkten för extra egenskaper.

   deployment-ordinal/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-train-xgb
   description: A sample deployment that trains an XGBoost model for the UCI dataset.
   endpoint_name: uci-classifier-train
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Vår pipeline definieras i en funktion. Om du vill omvandla den till en komponent använder du egenskapen från den component . Pipelinekomponenter är återanvändbara beräkningsdiagram som kan ingå i batchdistributioner eller användas för att skapa mer komplexa pipelines.

   pipeline_component = ml_client.components.create_or_update(
       uci_heart_classifier_trainer().component
   )

   Nu kan vi definiera distributionen:

   deployment = PipelineComponentBatchDeployment(
       name="uci-classifier-train-xgb",
       description="A sample deployment that trains an XGBoost model for the UCI dataset.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

2. Skapa distributionen:

   Azure CLI

   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 -f deployment-ordinal/deployment.yml --set-default
   

   Dricks

   Observera att flaggan används --set-default för att ange att den nya distributionen nu är standard.

   Python

   Det här kommandot startar distributionen och returnerar ett bekräftelsesvar medan distributionen skapas.

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

3. Distributionen är klar för användning.

Testa distributionen

När distributionen har skapats är den redo att ta emot jobb. Följ dessa steg för att testa det:

1. Vår distribution kräver att vi anger en datainmatning.

   Azure CLI

   Filen inputs.yml innehåller definitionen för indatatillgången:

   inputs.yml

   inputs:
     input_data:
       type: uri_folder
       path: azureml:heart-classifier-train@latest
   

   Python

   Definiera indatatillgången:

   input_data = Input(type=AssetTypes.URI_FOLDER, path=heart_dataset_train.id)

   Dricks

   Mer information om hur du anger indata finns i Skapa jobb och indata för batchslutpunkter.

2. Du kan anropa standarddistributionen på följande sätt:

   Azure CLI

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

   Python

   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.

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name, inputs={"input_data": input_data}
   )

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

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

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

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

Det är värt att nämna att endast pipelinens indata publiceras som indata i batchslutpunkten. Till exempel categorical_encoding är en indata för ett steg i pipelinen, men inte en indata i själva pipelinen. Använd det här faktumet för att styra vilka indata som du vill exponera för dina klienter och vilka som du vill dölja.

Få åtkomst till jobbutdata

När jobbet har slutförts kan vi komma åt några av dess utdata. Den här pipelinen genererar följande utdata för komponenterna:

• preprocess job: utdata är transformations_output
• train job: utdata är model och evaluation_results

Du kan ladda ned de associerade resultaten med hjälp av:

Azure CLI

az ml job download --name $JOB_NAME --output-name transformations
az ml job download --name $JOB_NAME --output-name model
az ml job download --name $JOB_NAME --output-name evaluation_results

Python

ml_client.jobs.download(
    name=job.name, download_path=".", output_name="transformations_output"
)
ml_client.jobs.download(name=job.name, download_path=".", output_name="model")
ml_client.jobs.download(
    name=job.name, download_path=".", output_name="evaluation_results"
)

Skapa en ny distribution i slutpunkten

Slutpunkter kan vara värdar för flera distributioner samtidigt, samtidigt som endast en distribution hålls som standard. Därför kan du iterera över dina olika modeller, distribuera de olika modellerna till slutpunkten och testa dem och slutligen växla standarddistributionen till den modelldistribution som passar dig bäst.

Nu ska vi ändra hur förbearbetningen görs i pipelinen för att se om vi får en modell som presterar bättre.

Ändra en parameter i pipelinens förbearbetningskomponent

Förbearbetningskomponenten har en indata som heter categorical_encoding, som kan ha värden ordinal eller onehot. Dessa värden motsvarar två olika sätt att koda kategoriska funktioner.

• ordinal: Kodar funktionsvärdena med numeriska värden (ordningstal) från [1:n], där n är antalet kategorier i funktionen. Ordningsföljdskodning innebär att det finns en naturlig rangordning bland funktionskategorierna.
• onehot: Innebär inte en naturlig rangordningsordning, men introducerar ett dimensionsproblem om antalet kategorier är stort.

Som standard använde ordinal vi tidigare. Nu ska vi ändra den kategoriska kodningen så att den används onehot och se hur modellen fungerar.

Dricks

Alternativt kan vi ha exponerat categorial_encoding indata för klienter som indata för själva pipelinejobbet. Vi valde dock att ändra parametervärdet i förbearbetningssteget så att vi kan dölja och kontrollera parametern i distributionen och dra nytta av möjligheten att ha flera distributioner under samma slutpunkt.

1. Ändra pipelinen. Det ser ut så här:

   Azure CLI

   Pipelinekonfigurationen definieras i deployment-onehot/pipeline.yml filen:

   deployment-onehot/pipeline.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
   type: pipeline
   
   name: uci-heart-train-pipeline
   display_name: uci-heart-train
   description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.
   
   inputs:
     input_data:
       type: uri_folder
   
   outputs: 
     model:
       type: mlflow_model
       mode: upload
     evaluation_results:
       type: uri_folder
       mode: upload
     prepare_transformations:
       type: uri_folder
       mode: upload
   
   jobs:
     preprocess_job:
       type: command
       component: ../components/prepare/prepare.yml
       inputs:
         data: ${{parent.inputs.input_data}}
         categorical_encoding: onehot
       outputs:
         prepared_data:
         transformations_output: ${{parent.outputs.prepare_transformations}}
     
     train_job:
       type: command
       component: ../components/train_xgb/train_xgb.yml
       inputs:
         data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
         target_column: target
         eval_size: 0.3
       outputs:
         model: 
           type: mlflow_model
           path: ${{parent.outputs.model}}
         evaluation_results:
           type: uri_folder
           path: ${{parent.outputs.evaluation_results}}
   

   Python

   @pipeline()
   def uci_heart_classifier_onehot(input_data: Input(type=AssetTypes.URI_FOLDER)):
       prepared_data = prepare_data(data=input_data, categorical_encoding="onehot")
       trained_model = train_xgb(
           data=prepared_data.outputs.prepared_data,
           target_column="target",
           register_best_model=False,
           eval_size=0.3,
       )
   
       return {
           "model": trained_model.outputs.model,
           "evaluation_results": trained_model.outputs.evaluation_results,
           "transformations_output": prepared_data.outputs.transformations_output,
       }

2. Konfigurera distributionen:

   Azure CLI

   Filen deployment-onehot/deployment.yml innehåller distributionens konfiguration. Du kan kontrollera YAML-schemat för den fullständiga batchslutpunkten för extra egenskaper.

   deployment-onehot/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-train-onehot
   description: A sample deployment that trains an XGBoost model for the UCI dataset using onehot encoding for variables.
   endpoint_name: uci-classifier-train
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Vår pipeline definieras i en funktion. Om du vill transformera den till en komponent använder build() du metoden. Pipelinekomponenter är återanvändbara beräkningsdiagram som kan ingå i batchdistributioner eller användas för att skapa mer komplexa pipelines.

   pipeline_component = uci_heart_classifier_onehot._pipeline_builder.build()

   Nu kan vi definiera distributionen:

   deployment_onehot = PipelineComponentBatchDeployment(
       name="uci-classifier-train-onehot",
       description="A sample deployment that trains an XGBoost model for the UCI dataset with one hot encoding of categorical variables.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

3. Skapa distributionen:

   Azure CLI

   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 -f deployment-onehot/deployment.yml
   

   Distributionen är klar för användning.

   Python

   Det här kommandot startar distributionen och returnerar ett bekräftelsesvar medan distributionen skapas.

   ml_client.batch_deployments.begin_create_or_update(deployment_onehot).result()

4. Distributionen är klar för användning.

Testa en nondefault-distribution

När distributionen har skapats är den redo att ta emot jobb. Vi kan testa det på samma sätt som tidigare, men nu anropar vi en specifik distribution:

1. Anropa distributionen på följande sätt och ange distributionsparametern för att utlösa den specifika distributionen uci-classifier-train-onehot:

   Azure CLI

   DEPLOYMENT_NAME="uci-classifier-train-onehot"
   JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME -d $DEPLOYMENT_NAME --f inputs.yml --query name -o tsv)
   

   Python

   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.

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name,
       deployment_name=deployment_onehot.name,
       inputs={"input_data": input_data},
   )

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

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   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)

Konfigurera den nya distributionen som standard

När vi är nöjda med den nya distributionens prestanda kan vi ange den här nya som standard:

Azure CLI

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

Python

endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

Ta bort den gamla distributionen

När du är klar kan du ta bort den gamla distributionen om du inte behöver den längre:

Azure CLI

az ml batch-deployment delete --name uci-classifier-train-xgb --endpoint-name $ENDPOINT_NAME --yes

Python

ml_client.batch_deployments.begin_delete(
    name=deployment.name, endpoint_name=endpoint.name
).result()

Rensa resurser

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

Azure CLI

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

Python

Ta bort slutpunkten:

ml_client.batch_endpoints.begin_delete(endpoint_name).result()

(Valfritt) Ta bort beräkning, såvida du inte planerar att återanvända beräkningsklustret med senare distributioner.

Azure CLI

az ml compute delete -n batch-cluster

Python

ml_client.compute.begin_delete(name="batch-cluster")

Nästa steg

• Så här distribuerar du en pipeline för att utföra batchbedömning med förbearbetning
• Skapa batchslutpunkter från pipelinejobb
• Komma åt data från batchslutpunktsjobb
• Felsöka batchslutpunkter