Zprovoznění trénovacího kanálu pomocí dávkových koncových bodů

PLATÍ PRO:Rozšíření Azure CLI ml v2 (aktuální)Python SDK azure-ai-ml v2 (aktuální)

V tomto článku se dozvíte, jak zprovoznit trénovací kanál v rámci dávkového koncového bodu. Kanál používá více komponent (nebo kroků), které zahrnují trénování modelu, předběžné zpracování dat a vyhodnocení modelu.

Naučíte se:

• Vytvoření a otestování trénovacího kanálu
• Nasazení kanálu do dávkového koncového bodu
• Úprava kanálu a vytvoření nového nasazení ve stejném koncovém bodu
• Otestujte nové nasazení a nastavte ho jako výchozí nasazení.

O tomto příkladu

Tento příklad nasadí trénovací kanál, který přijímá vstupní trénovací data (označená) a vytvoří prediktivní model spolu s výsledky vyhodnocení a transformacemi použitými během předběžného zpracování. Kanál použije tabulková data ze sady dat UCI Heart Disease Data Set k trénování modelu XGBoost. Komponentu předběžného zpracování dat používáme k předběžnému zpracování dat před odesláním do trénovací komponenty, aby se přizpůsobila a vyhodnotila model.

Vizualizace kanálu je následující:

Příklad v tomto článku vychází z ukázek kódu obsažených v úložišti azureml-examples . Pokud chcete příkazy spustit místně, aniž byste museli kopírovat nebo vkládat YAML a další soubory, naklonujte úložiště pomocí následujících příkazů a přejděte do složky pro váš kódovací jazyk:

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

Soubory pro tento příklad jsou v:

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

Sledování v poznámkových blocích Jupyter

Verzi sady Python SDK tohoto příkladu můžete sledovat otevřením poznámkového bloku sdk-deploy-and-test.ipynb v naklonovaném úložišti.

Požadavky

• Předplatné Azure. Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet.

• Pracovní prostor služby Azure Machine Learning. Pokud chcete vytvořit pracovní prostor, přečtěte si téma Správa pracovních prostorů Služby Azure Machine Learning.

• Následující oprávnění v pracovním prostoru Azure Machine Learning:

  • Pro vytváření nebo správu dávkových koncových bodů a nasazení: Použijte roli Vlastník, Přispěvatel nebo Vlastní role, která má přiřazená Microsoft.MachineLearningServices/workspaces/batchEndpoints/* oprávnění.
  • Vytváření nasazení Azure Resource Manageru ve skupině prostředků pracovního prostoru: Použijte roli Vlastník, Přispěvatel nebo Vlastní role, která má přiřazená Microsoft.Resources/deployments/write oprávnění ve skupině prostředků, ve které je pracovní prostor nasazený.

• Azure Machine Learning CLI nebo sada Azure Machine Learning SDK pro Python:

  Azure CLI

  Spuštěním následujícího příkazu nainstalujte Azure CLI a ml rozšíření pro Azure Machine Learning:

  az extension add -n ml
  

  Nasazení součástí kanálu pro dávkové koncové body jsou zavedena ve verzi 2.7 ml rozšíření pro Azure CLI. az extension update --name ml Pomocí příkazu získejte nejnovější verzi.

  Python

  Spuštěním následujícího příkazu nainstalujte sadu Azure Machine Learning SDK pro Python:

  pip install azure-ai-ml
  

  Třídy ModelBatchDeployment a PipelineComponentBatchDeployment třídy jsou zavedeny ve verzi 1.7.0 sady SDK. pip install -U azure-ai-ml Pomocí příkazu získejte nejnovější verzi.

---

Připojení k pracovnímu prostoru

Pracovní prostor je prostředek nejvyšší úrovně pro Azure Machine Learning. Poskytuje centralizované místo pro práci se všemi artefakty, které vytvoříte při použití služby Azure Machine Learning. V této části se připojíte k pracovnímu prostoru, ve kterém provádíte úlohy nasazení.

Azure CLI

V následujícím příkazu zadejte ID předplatného, název pracovního prostoru, název skupiny prostředků a umístění:

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

Python

1. Import požadovaných knihoven:

   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. Nakonfigurujte podrobnosti pracovního prostoru a získejte popisovač pracovního prostoru:

   V následujícím příkazu zadejte ID předplatného, název skupiny prostředků a název pracovního prostoru:

   subscription_id = "<subscription>"
   resource_group = "<resource-group>"
   workspace = "<workspace>"
   
   ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
   

Vytvoření komponenty trénovacího kanálu

V této části vytvoříme všechny prostředky potřebné pro náš trénovací kanál. Začneme vytvořením prostředí, které zahrnuje potřebné knihovny pro trénování modelu. Pak vytvoříme výpočetní cluster, na kterém se bude dávkové nasazení spouštět, a nakonec zaregistrujeme vstupní data jako datový prostředek.

Vytvoření prostředí

Komponenty v tomto příkladu budou používat prostředí s knihovnamiXGBoost.scikit-learn Soubor environment/conda.yml obsahuje konfiguraci prostředí:

prostředí/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

Vytvořte prostředí následujícím způsobem:

1. Definujte prostředí:

   Azure CLI

   prostředí/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. Vytvořte prostředí:

   Azure CLI

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

   Python

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

Vytvoření výpočetního clusteru

Koncové body a nasazení služby Batch běží na výpočetních clusterech. Můžou běžet na libovolném výpočetním clusteru Azure Machine Learning, který už v pracovním prostoru existuje. Proto může několik dávkových nasazení sdílet stejnou výpočetní infrastrukturu. V tomto příkladu budeme pracovat na výpočetním clusteru Azure Machine Learning s názvem batch-cluster. Pojďme ověřit, jestli výpočetní prostředky v pracovním prostoru existují, nebo je vytvořit jinak.

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

Registrace trénovacích dat jako datového prostředku

Naše trénovací data jsou reprezentována v souborech CSV. Abychom napodobovali více úloh na produkční úrovni, zaregistrujeme trénovací data v heart.csv souboru jako datový prostředek v pracovním prostoru. Tento datový asset se později označí jako vstup do koncového bodu.

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

Vytvoření datového assetu:

ml_client.data.create_or_update(heart_dataset_train)

Pojďme získat odkaz na nový datový asset:

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

Vytvoření kanálu

Kanál, který chceme zprovoznit, přijímá jeden vstup, trénovací data a vytváří tři výstupy: trénovaný model, výsledky vyhodnocení a transformace dat použité jako předběžné zpracování. Kanál se skládá ze dvou komponent:

• preprocess_job: Tento krok přečte vstupní data a vrátí připravená data a použité transformace. Krok přijímá tři vstupy:
  • data: složka obsahující vstupní data pro transformaci a skóre
  • transformations: (volitelné) Cesta k transformacím, které budou použity, pokud jsou k dispozici. Pokud cesta není zadaná, transformace se z vstupních dat naučí. Vzhledem k tomu, že transformations vstup je volitelný, lze komponentu preprocess_job použít během trénování a vyhodnocování.
  • categorical_encoding: strategie kódování pro kategorické funkce (ordinal nebo onehot).
• train_job: Tento krok vytrénuje model XGBoost na základě připravených dat a vrátí výsledky vyhodnocení a natrénovaný model. Krok přijímá tři vstupy:
  • data: předzpracovaná data.
  • target_column: sloupec, který chceme předpovědět.
  • eval_size: určuje podíl vstupních dat použitých k vyhodnocení.

Azure CLI

Konfigurace kanálu je definována deployment-ordinal/pipeline.yml v souboru:

řadový/pipeline.yml nasazení

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

Poznámka:

pipeline.yml V souboru transformations chybí preprocess_jobvstup , a proto skript naučí transformační parametry ze vstupních dat.

Python

Konfigurace komponent kanálu jsou v souborech a train_xgb.yml souborechprepare.yml. Načtěte komponenty:

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

Vytvoření kanálu:

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

Poznámka:

V kanálu transformations chybí vstup, proto se skript naučí parametry ze vstupních dat.

Vizualizace kanálu je následující:

Otestování kanálu

Pojďme kanál otestovat pomocí ukázkových dat. K tomu vytvoříme úlohu pomocí kanálu a výpočetního clusteru vytvořeného batch-cluster dříve.

Azure CLI

Následující pipeline-job.yml soubor obsahuje konfiguraci pro úlohu kanálu:

pořadí nasazení/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)
)

Teď nakonfigurujeme některá nastavení spuštění pro spuštění testu:

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

Vytvořte testovací úlohu:

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

Vytvoření dávkového koncového bodu

1. Zadejte název koncového bodu. Název dávkového koncového bodu musí být v každé oblasti jedinečný, protože se tento název používá k vytvoření identifikátoru URI vyvolání. Pokud chcete zajistit jedinečnost, připojte k názvu zadanému v následujícím kódu všechny koncové znaky.

   Azure CLI

   ENDPOINT_NAME="uci-classifier-train"
   

   Python

   endpoint_name = "uci-classifier-train"

2. Konfigurace koncového bodu:

   Azure CLI

   Soubor endpoint.yml obsahuje konfiguraci koncového bodu.

   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. Vytvořte koncový bod:

   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. Zadejte dotaz na identifikátor URI koncového bodu:

   Azure CLI

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

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

Nasazení komponenty kanálu

Abychom mohli nasadit komponentu kanálu, musíme vytvořit dávkové nasazení. Nasazení je sada prostředků potřebných k hostování prostředku, který provádí skutečnou práci.

1. Konfigurace nasazení:

   Azure CLI

   Soubor deployment-ordinal/deployment.yml obsahuje konfiguraci nasazení. Můžete zkontrolovat, jestli schéma YAML celého dávkového koncového bodu obsahuje další vlastnosti.

   řadový/deployment.yml nasazení

   $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

   Náš kanál je definován ve funkci. Pokud ho chcete transformovat na komponentu, použijete z component ní vlastnost. Komponenty kanálu jsou opakovaně použitelné výpočetní grafy, které je možné zahrnout do dávkových nasazení nebo použít k vytváření složitějších kanálů.

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

   Teď můžeme definovat nasazení:

   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. Vytvořte nasazení:

   Azure CLI

   Spuštěním následujícího kódu vytvořte dávkové nasazení v rámci koncového bodu dávky a nastavte ho jako výchozí nasazení.

   az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default
   

   Tip

   Všimněte si použití příznaku --set-default k označení, že toto nové nasazení je teď výchozí.

   Python

   Tento příkaz spustí vytvoření nasazení a během vytváření nasazení vrátí potvrzovací odpověď.

   ml_client.batch_deployments.begin_create_or_update(deployment).result()

   Po vytvoření nakonfigurujeme toto nové nasazení jako výchozí:

   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. Vaše nasazení je připravené k použití.

Otestování nasazení

Jakmile se nasazení vytvoří, je připravené přijímat úlohy. K otestování postupujte takto:

1. Naše nasazení vyžaduje, abychom označili jeden vstup dat.

   Azure CLI

   Soubor inputs.yml obsahuje definici vstupního datového prostředku:

   inputs.yml

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

   Python

   Definujte vstupní datový asset:

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

   Tip

   Další informace o tom, jak označit vstupy, najdete v tématu Vytváření úloh a vstupních dat pro dávkové koncové body.

2. Výchozí nasazení můžete vyvolat následujícím způsobem:

   Azure CLI

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

   Python

   Tip

   Jaký je rozdíl mezi parametrem inputs při input vyvolání koncového bodu?

   Obecně můžete pomocí parametru slovníku inputs = {} invoke s metodou poskytnout libovolný počet požadovaných vstupů do dávkového koncového bodu, který obsahuje nasazení modelu nebo nasazení kanálu.

   Pro nasazení modelu můžete parametr použít input jako kratší způsob určení umístění vstupních dat pro nasazení. Tento přístup funguje, protože nasazení modelu vždy přijímá pouze jeden vstup dat.

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

3. Průběh zobrazení a streamování protokolů můžete sledovat pomocí:

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Pokud chcete počkat na dokončení úlohy, spusťte následující kód:

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

Stojí za zmínku, že se v koncovém bodu dávky publikují jenom vstupy kanálu jako vstupy. Je to například categorical_encoding vstup kroku kanálu, ale ne vstup v samotném kanálu. Pomocí této skutečnosti můžete řídit, které vstupy chcete zpřístupnit klientům a které z nich chcete skrýt.

Přístup k výstupům úlohy

Po dokončení úlohy můžeme získat přístup k některým jeho výstupům. Tento kanál vytvoří pro své komponenty následující výstupy:

• preprocess job: výstup je transformations_output
• train job: výstupy jsou model a evaluation_results

Přidružené výsledky si můžete stáhnout pomocí:

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

Vytvoření nového nasazení v koncovém bodu

Koncové body můžou hostovat více nasazení najednou a současně ponechat jako výchozí jenom jedno nasazení. Proto můžete iterovat různé modely, nasadit různé modely do koncového bodu a otestovat je a nakonec přepnout výchozí nasazení na nasazení modelu, které je pro vás nejvhodnější.

Pojďme změnit způsob provádění předběžného zpracování v kanálu, abychom zjistili, jestli získáme model, který funguje lépe.

Změna parametru v komponentě předběžného zpracování kanálu

Komponenta předběžného zpracování má vstupní název categorical_encoding, který může mít hodnoty ordinal nebo onehot. Tyto hodnoty odpovídají dvěma různým způsobům kódování kategorických funkcí.

• ordinal: Zakóduje hodnoty funkcí pomocí číselných hodnot (řadových) z [1:n], kde n je počet kategorií ve funkci. Pořadové kódování znamená, že mezi kategoriemi funkcí je přirozené pořadí.
• onehot: Neznamená přirozený vztah seřazený podle pořadí, ale představuje problém s dimenzionalitou, pokud je počet kategorií velký.

Ve výchozím nastavení jsme použili ordinal dříve. Teď změníme kategorické kódování tak, aby se používalo onehot , a podívejme se, jak model funguje.

Tip

Případně bychom mohli zpřístupnit categorial_encoding vstup klientům jako vstup pro samotnou úlohu kanálu. Rozhodli jsme se ale změnit hodnotu parametru v kroku předběžného zpracování, abychom mohli skrýt a řídit parametr uvnitř nasazení a využít možnost mít více nasazení ve stejném koncovém bodu.

1. Upravte kanál. Vypadá takto:

   Azure CLI

   Konfigurace kanálu je definována deployment-onehot/pipeline.yml v souboru:

   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. Konfigurace nasazení:

   Azure CLI

   Soubor deployment-onehot/deployment.yml obsahuje konfiguraci nasazení. Můžete zkontrolovat, jestli schéma YAML celého dávkového koncového bodu obsahuje další vlastnosti.

   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

   Náš kanál je definován ve funkci. K transformaci na komponentu použijete metodu build() . Komponenty kanálu jsou opakovaně použitelné výpočetní grafy, které je možné zahrnout do dávkových nasazení nebo použít k vytváření složitějších kanálů.

   pipeline_component = uci_heart_classifier_onehot._pipeline_builder.build()

   Teď můžeme definovat nasazení:

   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. Vytvořte nasazení:

   Azure CLI

   Spuštěním následujícího kódu vytvořte dávkové nasazení v rámci koncového bodu dávky a nastavte ho jako výchozí nasazení.

   az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-onehot/deployment.yml
   

   Vaše nasazení je připravené k použití.

   Python

   Tento příkaz spustí vytvoření nasazení a během vytváření nasazení vrátí potvrzovací odpověď.

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

4. Vaše nasazení je připravené k použití.

Testování nedefaultních nasazení

Jakmile se nasazení vytvoří, je připravené přijímat úlohy. Můžeme ho otestovat stejným způsobem jako předtím, ale teď vyvoláme konkrétní nasazení:

1. Následujícím způsobem spusťte nasazení zadáním parametru nasazení, který aktivuje konkrétní nasazení 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

   Tip

   Jaký je rozdíl mezi parametrem inputs při input vyvolání koncového bodu?

   Obecně můžete pomocí parametru slovníku inputs = {} invoke s metodou poskytnout libovolný počet požadovaných vstupů do dávkového koncového bodu, který obsahuje nasazení modelu nebo nasazení kanálu.

   Pro nasazení modelu můžete parametr použít input jako kratší způsob určení umístění vstupních dat pro nasazení. Tento přístup funguje, protože nasazení modelu vždy přijímá pouze jeden vstup dat.

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

2. Průběh zobrazení a streamování protokolů můžete sledovat pomocí:

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

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

   Pokud chcete počkat na dokončení úlohy, spusťte následující kód:

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

Nakonfigurujte nové nasazení jako výchozí.

Jakmile budeme spokojeni s výkonem nového nasazení, můžeme tuto novou nastavit jako výchozí:

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

Odstranění starého nasazení

Jakmile budete hotovi, můžete staré nasazení odstranit, pokud už ho nepotřebujete:

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

Vyčištění prostředků

Jakmile budete hotovi, odstraňte přidružené prostředky z pracovního prostoru:

Azure CLI

Spuštěním následujícího kódu odstraňte koncový bod dávky a jeho základní nasazení. --yes slouží k potvrzení odstranění.

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

Python

Odstraňte koncový bod:

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

(Volitelné) Odstraňte výpočetní prostředky, pokud neplánujete znovu použít výpočetní cluster s pozdějším nasazením.

Azure CLI

az ml compute delete -n batch-cluster

Python

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

Další kroky

• Nasazení kanálu pro dávkové vyhodnocování pomocí předběžného zpracování
• Vytvoření dávkových koncových bodů z úloh kanálu
• Přístup k datům z dávkových úloh koncových bodů
• Řešení potíží s dávkovými koncovými body