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

Článek
12/21/2023

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, nejprve naklonujte úložiště a pak změňte adresáře do složky:

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

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

Než budete postupovat podle kroků v tomto článku, ujistěte se, že máte následující požadavky:

Předplatné Azure. Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet. Vyzkoušejte bezplatnou nebo placenou verzi služby Azure Machine Učení.
Pracovní prostor služby Azure Machine Learning. Pokud ho nemáte, vytvořte ho pomocí kroků v článku Správa Učení pracovních prostorů Azure.
Ujistěte se, že máte v pracovním prostoru následující oprávnění:
- Vytváření nebo správa dávkových koncových bodů a nasazení: Použijte roli Vlastník, Přispěvatel nebo Vlastní, která umožňuje Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Vytvořte nasazení ARM ve skupině prostředků pracovního prostoru: Použijte roli Vlastník, Přispěvatel nebo Vlastní, která umožňuje Microsoft.Resources/deployments/write ve skupině prostředků, ve které je pracovní prostor nasazený.
Abyste mohli pracovat se službou Azure Machine Učení, musíte nainstalovat následující software:
- Azure CLI
- Python
Azure CLI a mlrozšíření pro azure machine Učení.
```
az extension add -n ml
```
Poznámka:

Nasazení součástí kanálu pro koncové body služby Batch byla zavedena ve verzi 2.7 ml rozšíření pro Azure CLI. Slouží az extension update --name ml k získání poslední verze.
Sada Azure Machine Učení SDK pro Python
```
pip install azure-ai-ml
```
Poznámka:

Třídy ModelBatchDeployment a PipelineComponentBatchDeployment byly zavedeny ve verzi 1.7.0 sady SDK. Slouží pip install -U azure-ai-ml k získání poslední verze.

Připojení k pracovnímu prostoru

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

Azure CLI
Python

Hodnoty ID předplatného, pracovního prostoru, umístění a skupiny prostředků předejte v následujícím kódu:

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

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

Nakonfigurujte podrobnosti pracovního prostoru a získejte popisovač pracovního prostoru:

Hodnoty ID předplatného, pracovního prostoru a skupiny prostředků předejte v následujícím kódu:
```
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:

Definujte prostředí:

Azure CLI
Python

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.

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

Vytvořte prostředí:

Azure CLI
Python

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

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 jakémkoli počítači Azure Učení výpočetním clusteru, 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 Učení 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
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()

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

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
Python

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.

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
Python

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

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

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

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

Konfigurace koncového bodu:

Azure CLI
Python

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

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

Vytvořte koncový bod:

Azure CLI
Python

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

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

Zadejte dotaz na identifikátor URI koncového bodu:

Azure CLI
Python

az ml batch-endpoint show --name $ENDPOINT_NAME

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.

Konfigurace nasazení:

Azure CLI
Python

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

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

Vytvořte nasazení:
- Azure CLI
- Python
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í.
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()
```
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:

Naše nasazení vyžaduje, abychom označili jeden vstup dat.
- Azure CLI
- Python
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
```
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.
Výchozí nasazení můžete vyvolat následujícím způsobem:
- Azure CLI
- Python
```
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
```
Tip

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

Obecně můžete pomocí 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 použít input kratší způsob, jak určit umístění vstupních dat pro nasazení, 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}
)
```
Průběh zobrazení a streamování protokolů můžete sledovat pomocí:
- Azure CLI
- Python
```
az ml job stream -n $JOB_NAME
```
```
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
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"
)

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.

Upravte kanál. Vypadá takto:

Azure CLI
Python

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

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

Konfigurace nasazení:

Azure CLI
Python

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

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

Vytvořte nasazení:
- Azure CLI
- Python
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í.
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()
```
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í:

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

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

Obecně můžete pomocí 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 použít input kratší způsob, jak určit umístění vstupních dat pro nasazení, 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},
)
```
Průběh zobrazení a streamování protokolů můžete sledovat pomocí:
- Azure CLI
- Python
```
az ml job stream -n $JOB_NAME
```
```
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
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()

Odstranění starého nasazení

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

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

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

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

Azure CLI
Python

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

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
Python

az ml compute delete -n batch-cluster

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