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

Artikel
09/01/2024

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

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:

Definiera miljön:

Azure CLI
Python

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.

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

Skapa miljön:

Azure CLI
Python

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

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
Python

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

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
Python

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

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
Python

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.

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
Python

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

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
Python

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

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

Skapa en batchslutpunkt

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="uci-classifier-train"
```
```
endpoint_name = "uci-classifier-train"
```

Konfigurera slutpunkten:

Azure CLI
Python

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

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

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

Konfigurera distributionen:

Azure CLI
Python

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

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

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 -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.
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()
```
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:

Vår distribution kräver att vi anger en datainmatning.
- Azure CLI
- Python
Filen inputs.yml innehåller definitionen för indatatillgången:

inputs.yml
```
inputs:
  input_data:
    type: uri_folder
    path: azureml:heart-classifier-train@latest
```
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.
Du kan anropa standarddistributionen på följande sätt:
- Azure CLI
- Python
```
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
```
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}
)
```
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(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
Python

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

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.

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

Azure CLI
Python

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

@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,
    }

Konfigurera distributionen:

Azure CLI
Python

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

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

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 -f deployment-onehot/deployment.yml
```
Distributionen är klar för användning.
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()
```
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:

Anropa distributionen på följande sätt och ange distributionsparametern för att utlösa den specifika distributionen uci-classifier-train-onehot:
- Azure CLI
- Python
```
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)
```
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},
)
```
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)
```

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
Python

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

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
Python

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

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

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

Azure CLI
Python

az ml compute delete -n batch-cluster

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

Dela via