Een trainingspijplijn operationeel maken met batch-eindpunten

Artikel
12/21/2023

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

In dit artikel leert u hoe u een trainingspijplijn onder een batch-eindpunt operationeel kunt maken. De pijplijn maakt gebruik van meerdere onderdelen (of stappen) die modeltraining, gegevensvoorverwerking en modelevaluatie omvatten.

U leert het volgende:

Een trainingspijplijn maken en testen
De pijplijn implementeren in een batch-eindpunt
Wijzig de pijplijn en maak een nieuwe implementatie in hetzelfde eindpunt
De nieuwe implementatie testen en instellen als de standaardimplementatie

Over dit voorbeeld

In dit voorbeeld wordt een trainingspijplijn geïmplementeerd die invoertrainingsgegevens (gelabeld) gebruikt en een voorspellend model produceert, samen met de evaluatieresultaten en de transformaties die tijdens de voorverwerking zijn toegepast. De pijplijn gebruikt tabellaire gegevens uit de UCI-gegevensset voor heart disease om een XGBoost-model te trainen. We gebruiken een voorverwerkingsonderdeel voor gegevens om de gegevens vooraf te verwerken voordat deze naar het trainingsonderdeel worden verzonden om het model aan te passen en te evalueren.

Een visualisatie van de pijplijn is als volgt:

Het voorbeeld in dit artikel is gebaseerd op codevoorbeelden in de opslagplaats azureml-examples . Als u de opdrachten lokaal wilt uitvoeren zonder YAML en andere bestanden te hoeven kopiëren/plakken, kloont u eerst de opslagplaats en wijzigt u vervolgens mappen in de map:

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

De bestanden voor dit voorbeeld bevinden zich in:

cd endpoints/batch/deploy-pipelines/training-with-components

Volgen in Jupyter-notebooks

U kunt de Python SDK-versie van dit voorbeeld volgen door het notebook sdk-deploy-and-test.ipynb te openen in de gekloonde opslagplaats.

Vereisten

Voordat u de stappen in dit artikel volgt, moet u ervoor zorgen dat u over de volgende vereisten beschikt:

Een Azure-abonnement. Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint. Probeer de gratis of betaalde versie van Azure Machine Learning.
Een Azure Machine Learning-werkruimte. Als u nog geen werkruimte hebt, gebruikt u de stappen in het artikel Azure Machine Learning-werkruimten beheren om er een te maken.
Zorg ervoor dat u over de volgende machtigingen in de werkruimte beschikt:
- Batch-eindpunten en -implementaties maken of beheren: gebruik een eigenaar, inzender of aangepaste rol die dit toestaat Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- ARM-implementaties maken in de resourcegroep van de werkruimte: gebruik een eigenaar, inzender of aangepaste rol die het mogelijk maakt Microsoft.Resources/deployments/write in de resourcegroep waarin de werkruimte wordt geïmplementeerd.
U moet de volgende software installeren om te kunnen werken met Azure Machine Learning:
- Azure-CLI
- Python
De Azure CLI en de ml extensie voor Azure Machine Learning.
```
az extension add -n ml
```
Notitie

Implementaties van pijplijnonderdelen voor Batch-eindpunten zijn geïntroduceerd in versie 2.7 van de ml extensie voor Azure CLI. Gebruik az extension update --name ml deze om de laatste versie ervan op te halen.
De Azure Machine Learning SDK voor Python.
```
pip install azure-ai-ml
```
Notitie

ModelBatchDeployment Klassen en PipelineComponentBatchDeployment zijn geïntroduceerd in versie 1.7.0 van de SDK. Gebruik pip install -U azure-ai-ml deze om de laatste versie ervan op te halen.

Verbinding maken met uw werkruimte

De werkruimte is de resource op het hoogste niveau voor Azure Machine Learning en biedt een gecentraliseerde werkplek met alle artefacten die u maakt in Azure Machine Learning. In deze sectie maken we verbinding met de werkruimte waarin u implementatietaken uitvoert.

Azure-CLI
Python

Geef de waarden voor uw abonnements-id, werkruimte, locatie en resourcegroep door in de volgende code:

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

Importeer de vereiste bibliotheken:

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

Configureer de details van de werkruimte en haal een ingang op voor de werkruimte:

Geef de waarden voor uw abonnements-id, werkruimte en resourcegroep door in de volgende code:

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

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

Het trainingspijplijnonderdeel maken

In deze sectie maken we alle assets die nodig zijn voor onze trainingspijplijn. We beginnen met het maken van een omgeving die de benodigde bibliotheken bevat om het model te trainen. Vervolgens maken we een rekencluster waarop de batchimplementatie wordt uitgevoerd. Ten slotte registreren we de invoergegevens als een gegevensasset.

Maak de omgeving

De onderdelen in dit voorbeeld gebruiken een omgeving met de XGBoost en scikit-learn bibliotheken. Het environment/conda.yml bestand bevat de configuratie van de omgeving:

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

Maak de omgeving als volgt:

Definieer de omgeving:

Azure-CLI
Python

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

Maak de omgeving:

Azure-CLI
Python

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

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

Een rekencluster maken

Batch-eindpunten en -implementaties worden uitgevoerd op rekenclusters. Ze kunnen worden uitgevoerd op elk Azure Machine Learning-rekencluster dat al bestaat in de werkruimte. Daarom kunnen meerdere batchimplementaties dezelfde rekeninfrastructuur delen. In dit voorbeeld werken we aan een Azure Machine Learning-rekencluster met de naam batch-cluster. We gaan controleren of de berekening bestaat in de werkruimte of anders maken.

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

De trainingsgegevens registreren als een gegevensasset

Onze trainingsgegevens worden weergegeven in CSV-bestanden. Als u een workload op productieniveau wilt nabootsen, registreren we de trainingsgegevens in het heart.csv bestand als een gegevensasset in de werkruimte. Deze gegevensasset wordt later aangegeven als invoer voor het eindpunt.

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

Maak de gegevensasset:

ml_client.data.create_or_update(heart_dataset_train)

Laten we een verwijzing naar de nieuwe gegevensasset ophalen:

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

Maak de pijplijn

De pijplijn die we willen operationeel maken, heeft één invoer, de trainingsgegevens en produceert drie uitvoerwaarden: het getrainde model, de evaluatieresultaten en de gegevenstransformaties die als voorverwerking worden toegepast. De pijplijn bestaat uit twee onderdelen:

preprocess_job: Deze stap leest de invoergegevens en retourneert de voorbereide gegevens en de toegepaste transformaties. De stap ontvangt drie invoergegevens:
- data: een map met de invoergegevens die moeten worden getransformeerd en beoordeeld
- transformations: (optioneel) Pad naar de transformaties die worden toegepast, indien beschikbaar. Als het pad niet is opgegeven, worden de transformaties geleerd op basis van de invoergegevens. Omdat de transformations invoer optioneel is, kan het onderdeel worden gebruikt tijdens het preprocess_job trainen en scoren.
- categorical_encoding: de coderingsstrategie voor de categorische kenmerken (ordinal of onehot).
train_job: Deze stap traint een XGBoost-model op basis van de voorbereide gegevens en retourneert de evaluatieresultaten en het getrainde model. De stap ontvangt drie invoergegevens:
- data: de vooraf verwerkte gegevens.
- target_column: de kolom die we willen voorspellen.
- eval_size: geeft het aandeel aan van de invoergegevens die worden gebruikt voor evaluatie.

Azure-CLI
Python

De pijplijnconfiguratie is gedefinieerd in het deployment-ordinal/pipeline.yml bestand:

implementatie-ordinaal/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}}

Notitie

In het pipeline.yml bestand ontbreekt de transformations invoer in het preprocess_jobbestand; daarom leert het script de transformatieparameters van de invoergegevens.

De configuraties voor de pijplijnonderdelen bevinden zich in de prepare.yml en train_xgb.yml bestanden. Laad de onderdelen:

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

Maak de pijplijn:

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

Notitie

In de pijplijn ontbreekt de transformations invoer. Daarom leert het script de parameters van de invoergegevens.

Een visualisatie van de pijplijn is als volgt:

De pijplijn testen

We gaan de pijplijn testen met enkele voorbeeldgegevens. Hiervoor maken we een taak met behulp van de pijplijn en het batch-cluster rekencluster dat eerder is gemaakt.

Azure-CLI
Python

Het volgende pipeline-job.yml bestand bevat de configuratie voor de pijplijntaak:

implementatie-ordinaal/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 gaan we enkele uitvoeringsinstellingen configureren om de test uit te voeren:

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

Maak de testtaak:

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

Een batch-eindpunt maken

Geef een naam op voor het eindpunt. De naam van een batch-eindpunt moet uniek zijn in elke regio, omdat de naam wordt gebruikt om de aanroep-URI samen te stellen. Voeg eventuele volgtekens toe aan de naam die in de volgende code is opgegeven om de uniekheid te garanderen.
- Azure-CLI
- Python
```
ENDPOINT_NAME="uci-classifier-train"
```
```
endpoint_name = "uci-classifier-train"
```

Configureer het eindpunt:

Azure-CLI
Python

Het endpoint.yml bestand bevat de configuratie van het eindpunt.

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

Maak het eindpunt:

Azure-CLI
Python

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

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

Voer een query uit op de eindpunt-URI:

Azure-CLI
Python

az ml batch-endpoint show --name $ENDPOINT_NAME

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

Het pijplijnonderdeel implementeren

Om het pijplijnonderdeel te implementeren, moeten we een batchimplementatie maken. Een implementatie is een set resources die vereist is voor het hosten van de asset die het werkelijke werk uitvoert.

De implementatie configureren:

Azure-CLI
Python

Het deployment-ordinal/deployment.yml bestand bevat de configuratie van de implementatie. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.

implementatie-ordinaal/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

Onze pijplijn wordt gedefinieerd in een functie. Als u het wilt transformeren naar een onderdeel, gebruikt u de component eigenschap van het onderdeel. Pijplijnonderdelen zijn herbruikbare rekengrafieken die kunnen worden opgenomen in batchimplementaties of die kunnen worden gebruikt om complexere pijplijnen samen te stellen.

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

Nu kunnen we de implementatie definiëren:

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

De implementatie maken:
- Azure-CLI
- Python
Voer de volgende code uit om een batch-implementatie te maken onder het batch-eindpunt en deze in te stellen als de standaardimplementatie.
```
az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default
```
Tip

Let op het gebruik van de --set-default vlag om aan te geven dat deze nieuwe implementatie nu de standaardwaarde is.
Met deze opdracht wordt het maken van de implementatie gestart en wordt er een bevestigingsantwoord geretourneerd terwijl de implementatie wordt gemaakt.
```
ml_client.batch_deployments.begin_create_or_update(deployment).result()
```
Zodra deze nieuwe implementatie is gemaakt, gaan we deze nieuwe implementatie configureren als de standaardimplementatie:
```
endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
Uw implementatie is klaar voor gebruik.

De implementatie testen

Zodra de implementatie is gemaakt, kunt u taken ontvangen. Volg deze stappen om deze te testen:

Voor onze implementatie moeten we één gegevensinvoer aangeven.
- Azure-CLI
- Python
Het inputs.yml bestand bevat de definitie voor de invoergegevensasset:

inputs.yml
```
inputs:
  input_data:
    type: uri_folder
    path: azureml:heart-classifier-train@latest
```
Definieer de invoergegevensasset:
```
input_data = Input(type=AssetTypes.URI_FOLDER, path=heart_dataset_train.id)
```
Tip

Zie Taken en invoergegevens maken voor batcheindpunten voor meer informatie over het aangeven van invoer.
U kunt de standaardimplementatie als volgt aanroepen:
- Azure-CLI
- Python
```
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
```
Tip

Wat is het verschil tussen inputs en input wanneer u een eindpunt aanroept?

Over het algemeen kunt u een woordenlijst inputs = {} met de invoke methode gebruiken om een willekeurig aantal vereiste invoer op te geven aan een batch-eindpunt dat een modelimplementatie of een pijplijnimplementatie bevat.

Voor een modelimplementatie kunt u een kortere manier gebruiken input om de locatie van de invoergegevens voor de implementatie op te geven, omdat voor een modelimplementatie altijd slechts één gegevensinvoer nodig is.
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, inputs={"input_data": input_data}
)
```
U kunt de voortgang van de voorstelling controleren en de logboeken streamen met behulp van:
- Azure-CLI
- Python
```
az ml job stream -n $JOB_NAME
```
```
ml_client.jobs.get(job.name)
```
Voer de volgende code uit om te wachten tot de taak is voltooid:
```
ml_client.jobs.stream(name=job.name)
```

Het is de moeite waard om te vermelden dat alleen de invoer van de pijplijn wordt gepubliceerd als invoer in het batch-eindpunt. Is bijvoorbeeld categorical_encoding een invoer van een stap van de pijplijn, maar geen invoer in de pijplijn zelf. Gebruik dit feit om te bepalen welke invoer u beschikbaar wilt maken voor uw clients en welke u wilt verbergen.

Uitvoer van Access-taken

Zodra de taak is voltooid, hebben we toegang tot enkele van de uitvoer. Deze pijplijn produceert de volgende uitvoer voor de onderdelen:

preprocess job: uitvoer is transformations_output
train job: uitvoer zijn model en evaluation_results

U kunt de bijbehorende resultaten downloaden met behulp van:

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

Een nieuwe implementatie maken in het eindpunt

Eindpunten kunnen meerdere implementaties tegelijk hosten, terwijl slechts één implementatie als de standaardinstelling wordt behouden. Daarom kunt u uw verschillende modellen herhalen, de verschillende modellen implementeren op uw eindpunt en deze testen en ten slotte de standaardimplementatie overschakelen naar de modelimplementatie die het beste voor u werkt.

Laten we de manier wijzigen waarop voorverwerking in de pijplijn wordt uitgevoerd om te zien of we een model krijgen dat beter presteert.

Een parameter wijzigen in het voorverwerkingsonderdeel van de pijplijn

Het voorverwerkingsonderdeel heeft een invoer met de naam categorical_encoding, die waarden ordinal onehotof . Deze waarden komen overeen met twee verschillende manieren om categorische functies te coderen.

ordinal: Codeert de functiewaarden met numerieke waarden (rangtelwoorden) van [1:n]n waaruit het aantal categorieën in de functie is. Ordinale codering impliceert dat er een natuurlijke rangorde is tussen de functiecategorieën.
onehot: Impliceert geen geordende natuurlijke rangschikkingsrelatie, maar introduceert een dimensionaliteitsprobleem als het aantal categorieën groot is.

Standaard hebben we eerder gebruikt ordinal . We gaan nu de categorische codering wijzigen om te gebruiken onehot en te zien hoe het model presteert.

Tip

U kunt de categorial_encoding invoer ook beschikbaar maken voor clients als invoer voor de pijplijntaak zelf. We hebben er echter voor gekozen om de parameterwaarde in de voorverwerkingsstap te wijzigen, zodat we de parameter in de implementatie kunnen verbergen en beheren en profiteren van de mogelijkheid om meerdere implementaties onder hetzelfde eindpunt te hebben.

Wijzig de pijplijn. Het ziet er als volgt uit:

Azure-CLI
Python

De pijplijnconfiguratie is gedefinieerd in het deployment-onehot/pipeline.yml bestand:

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

De implementatie configureren:

Azure-CLI
Python

Het deployment-onehot/deployment.yml bestand bevat de configuratie van de implementatie. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.

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

Onze pijplijn wordt gedefinieerd in een functie. Als u deze wilt transformeren naar een onderdeel, gebruikt u de build() methode. Pijplijnonderdelen zijn herbruikbare rekengrafieken die kunnen worden opgenomen in batchimplementaties of die kunnen worden gebruikt om complexere pijplijnen samen te stellen.

pipeline_component = uci_heart_classifier_onehot._pipeline_builder.build()

Nu kunnen we de implementatie definiëren:

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

De implementatie maken:
- Azure-CLI
- Python
Voer de volgende code uit om een batch-implementatie te maken onder het batch-eindpunt en deze in te stellen als de standaardimplementatie.
```
az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-onehot/deployment.yml
```
Uw implementatie is klaar voor gebruik.
Met deze opdracht wordt het maken van de implementatie gestart en wordt er een bevestigingsantwoord geretourneerd terwijl de implementatie wordt gemaakt.
```
ml_client.batch_deployments.begin_create_or_update(deployment_onehot).result()
```
Uw implementatie is klaar voor gebruik.

Een niet-standaardimplementatie testen

Zodra de implementatie is gemaakt, kunt u taken ontvangen. We kunnen het testen op dezelfde manier als voorheen, maar nu gaan we een specifieke implementatie aanroepen:

Roep de implementatie als volgt aan en geef de implementatieparameter op om de specifieke implementatie uci-classifier-train-onehotte activeren:
- 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)
```
Tip

Wat is het verschil tussen inputs en input wanneer u een eindpunt aanroept?

Over het algemeen kunt u een woordenlijst inputs = {} met de invoke methode gebruiken om een willekeurig aantal vereiste invoer op te geven aan een batch-eindpunt dat een modelimplementatie of een pijplijnimplementatie bevat.

Voor een modelimplementatie kunt u een kortere manier gebruiken input om de locatie van de invoergegevens voor de implementatie op te geven, omdat voor een modelimplementatie altijd slechts één gegevensinvoer nodig is.
```
job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    deployment_name=deployment_onehot.name,
    inputs={"input_data": input_data},
)
```
U kunt de voortgang van de voorstelling controleren en de logboeken streamen met behulp van:
- Azure-CLI
- Python
```
az ml job stream -n $JOB_NAME
```
```
ml_client.jobs.get(name=job.name)
```
Voer de volgende code uit om te wachten tot de taak is voltooid:
```
ml_client.jobs.stream(name=job.name)
```

De nieuwe implementatie configureren als de standaardimplementatie

Zodra we tevreden zijn over de prestaties van de nieuwe implementatie, kunnen we deze nieuwe instellen als de standaardinstelling:

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

De oude implementatie verwijderen

Zodra u klaar bent, kunt u de oude implementatie verwijderen als u deze niet meer nodig hebt:

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

Resources opschonen

Wanneer u klaar bent, verwijdert u de gekoppelde resources uit de werkruimte:

Azure-CLI
Python

Voer de volgende code uit om het batch-eindpunt en de onderliggende implementatie te verwijderen. --yes wordt gebruikt om de verwijdering te bevestigen.

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

Verwijder het eindpunt:

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

(Optioneel) Verwijder rekenkracht, tenzij u van plan bent om uw rekencluster opnieuw te gebruiken met latere implementaties.

Azure-CLI
Python

az ml compute delete -n batch-cluster

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

Share via