Nasazení kanálu pro dávkové vyhodnocování pomocí předběžného zpracování

Č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 nasadit kanál odvozování (nebo bodování) v rámci dávkového koncového bodu. Kanál provádí bodování nad registrovaným modelem a zároveň opakovaně používá komponentu předběžného zpracování z trénovaného modelu. Opětovné použití stejné součásti předběžného zpracování zajišťuje, že se během vyhodnocování použije stejné předběžné zpracování.

Naučíte se:

Vytvoření kanálu, který znovu použije existující komponenty z pracovního prostoru
Nasazení kanálu do koncového bodu
Využívání předpovědí vygenerovaných kanálem

O tomto příkladu

Tento příklad ukazuje, jak znovu použít předzpracování kódu a parametry získané během předběžného zpracování, než použijete model k odvozování. Opětovným použitím kódu předzpracování a naučených parametrů můžeme zajistit, aby se během odvozování použily stejné transformace (například normalizace a kódování funkcí), které byly použity na vstupní data během trénování. Model použitý k odvozování provede předpovědi na tabulkových datech ze sady dat UCI Heart Disease.

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/batch-scoring-with-preprocessing

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í kanálu odvozování

V této části vytvoříme všechny prostředky potřebné pro náš kanál odvozování. Začneme vytvořením prostředí, které zahrnuje potřebné knihovny pro komponenty kanálu. V dalším kroku vytvoříme výpočetní cluster, na kterém se bude dávkové nasazení spouštět. Potom zaregistrujeme komponenty, modely a transformace, které potřebujeme k vytvoření kanálu odvozování. Nakonec kanál sestavíme a otestujeme.

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
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 komponent a modelů

Zaregistrujeme komponenty, modely a transformace, které potřebujeme k vytvoření kanálu odvozování. Některé z těchto prostředků můžeme znovu použít pro tréninkové rutiny.

Tip

V tomto kurzu znovu použijeme model a komponentu předběžného zpracování z dřívějšího trénovacího kanálu. Podle příkladu jak nasadit trénovací kanál s koncovými body batch můžete zjistit, jak byly vytvořeny.

Zaregistrujte model, který se má použít k predikci:

Azure CLI
Python

az ml model create --name heart-classifier --type mlflow_model --path model

model_name = "heart-classifier"
model_local_path = "model"

model = ml_client.models.create_or_update(
    Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

Registrovaný model nebyl vytrénován přímo na vstupní data. Místo toho se vstupní data před trénováním před trénováním předzpracovala (nebo transformovala). Tuto komponentu budeme také muset zaregistrovat. Zaregistrujte součást přípravy:
- Azure CLI
- Python
```
az ml component create -f components/prepare/prepare.yml
```
```
prepare_data = load_component(source="components/prepare/prepare.yml")

ml_client.components.create_or_update(prepare_data)
```
Tip

Po registraci komponenty přípravy na ni teď můžete odkazovat z pracovního prostoru. Například azureml:uci_heart_prepare@latest získáte poslední verzi součásti přípravy.

V rámci transformací dat v přípravě komponenty byla vstupní data normalizována tak, aby se zacentrovala prediktory a omezila jejich hodnoty v rozsahu [-1, 1]. Parametry transformace byly zachyceny v transformaci scikit-learn, kterou můžeme zaregistrovat i později, když máme nová data. Následujícím způsobem zaregistrujte transformaci:

Azure CLI
Python

az ml model create --name heart-classifier-transforms --type custom_model --path transformations

transformation_name = "heart-classifier-transforms"
transformation_local_path = "transformations"

transformations = ml_client.models.create_or_update(
    Model(
        name=transformation_name,
        path=transformation_local_path,
        type=AssetTypes.CUSTOM_MODEL,
    )
)

Pro zaregistrovaný model provedeme odvozování pomocí jiné komponenty s názvem score , která vypočítá predikce pro daný model. Na komponentu budeme odkazovat přímo z její definice.

Tip

Osvědčeným postupem je zaregistrovat komponentu a odkazovat na ni z kanálu. V tomto příkladu ale budeme odkazovat přímo na komponentu z její definice, abychom zjistili, které komponenty se znovu používají z trénovacího kanálu a které z nich jsou nové.

Sestavení kanálu

Teď je čas svázat všechny prvky dohromady. Kanál odvozování, který nasadíme, má dvě komponenty (kroky):

preprocess_job: Tento krok přečte vstupní data a vrátí připravená data a použité transformace. Krok přijímá dva vstupy:
- data: složka obsahující vstupní data pro určení skóre
- transformations: (volitelné) Cesta k transformacím, které budou použity, pokud jsou k dispozici. Pokud je k dispozici, transformace se čtou z modelu, který je uveden v cestě. Pokud ale cesta není zadaná, transformace se z vstupních dat naučí. Pro odvozování ale nemůžete zjistit parametry transformace (v tomto příkladu normalizační koeficienty) ze vstupních dat, protože potřebujete použít stejné hodnoty parametrů, které jste se naučili během trénování. Vzhledem k tomu, že tento vstup je volitelný, lze komponentu preprocess_job použít během trénování a vyhodnocování.
score_job: Tento krok provede odvozování transformovaných dat pomocí vstupního modelu. Všimněte si, že komponenta používá k odvozování model MLflow. Nakonec se skóre zapisují ve stejném formátu jako přečtené.

Azure CLI
Python

Konfigurace kanálu je definována pipeline.yml v souboru:

pipeline.yml

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

name: batch_scoring_uci_heart
display_name: Batch Scoring for UCI heart
description: This pipeline demonstrates how to make batch inference using a model from the Heart Disease Data Set problem, where pre and post processing is required as steps. The pre and post processing steps can be components reusable from the training pipeline.

inputs:
  input_data:
    type: uri_folder
  score_mode:
    type: string
    default: append

outputs: 
  scores:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: azureml:uci_heart_prepare@latest
    inputs:
      data: ${{parent.inputs.input_data}}
      transformations: 
        path: azureml:heart-classifier-transforms@latest
        type: custom_model
    outputs:
      prepared_data:
  
  score_job:
    type: command
    component: components/score/score.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      model:
        path: azureml:heart-classifier@latest
        type: mlflow_model
      score_mode: ${{parent.inputs.score_mode}}
    outputs:
      scores: 
        mode: upload
        path: ${{parent.outputs.scores}}

prepare_data = ml_client.components.get("uci_heart_prepare", label="latest")
score_data = load_component(source="components/score/score.yml")

Pojďme kanál sestavit ve funkci:

@pipeline()
def uci_heart_classifier_scorer(
    input_data: Input(type=AssetTypes.URI_FOLDER), score_mode: str
):
    """This pipeline demonstrates how to make batch inference using a model from the Heart Disease Data Set problem, where pre and post processing is required as steps. The pre and post processing steps can be components reusable from the training pipeline."""
    prepared_data = prepare_data(
        data=input_data,
        transformations=Input(type=AssetTypes.CUSTOM_MODEL, path=transformations.id),
    )
    scored_data = score_data(
        data=prepared_data.outputs.prepared_data,
        model=Input(type=AssetTypes.MLFLOW_MODEL, path=model.id),
        score_mode=score_mode,
    )

    return {"scores": scored_data.outputs.scores}

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:

pipeline-job.yml

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

display_name: uci-classifier-score-job
description: |-
  This pipeline demonstrate how to make batch inference using a model from the Heart \
  Disease Data Set problem, where pre and post processing is required as steps. The \
  pre and post processing steps can be components reused from the training pipeline.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
  score_mode: append
outputs: 
  scores:
    mode: upload

pipeline_job = uci_heart_classifier_scorer(
    input_data=Input(type="uri_folder", path="data/unlabeled/"), score_mode="append"
)

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 pipeline-job.yml --set inputs.input_data.path=data/unlabeled

pipeline_job_run = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="uci-heart-score-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-score"
```
```
endpoint_name = "uci-classifier-score"
```

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-score
description: Batch scoring endpoint of the Heart Disease Data Set prediction task.
auth_mode: aad_token

endpoint = BatchEndpoint(
    name=endpoint_name,
    description="Batch scoring endpoint 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.yml obsahuje konfiguraci nasazení. Můžete zkontrolovat, jestli schéma YAML celého dávkového koncového bodu obsahuje další vlastnosti.

deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
name: uci-classifier-prepros-xgb
endpoint_name: uci-classifier-batch
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_scorer().component
)

Teď můžeme definovat nasazení:

deployment = PipelineComponentBatchDeployment(
    name="uci-classifier-prepros-xgb",
    description="A sample deployment with pre and post processing done before and after inference.",
    endpoint_name=endpoint.name,
    component=pipeline_component,
    settings={"continue_on_step_failure": False, "default_compute": compute_name},
)

Vytvoření 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.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 a jeden literálový vstup.
- Azure CLI
- Python
Soubor inputs.yml obsahuje definici vstupního datového prostředku:

inputs.yml
```
inputs:
  input_data:
    type: uri_folder
    path: data/unlabeled
  score_mode:
    type: string
    default: append
outputs:
  scores:
    type: uri_folder
    mode: upload
```
Definice vstupního datového assetu:
```
input_data = Input(type="uri_folder", path="data/unlabeled/")
score_mode = Input(type="string", default="append")
```
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, "score_mode": score_mode},
)
```
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)
```

Výstup úlohy accessu

Po dokončení úlohy můžeme získat přístup k jeho výstupu. Tato úloha obsahuje pouze jeden výstup s názvem scores:

Azure CLI
Python

Přidružené výsledky si můžete stáhnout pomocí az ml job download.

az ml job download --name $JOB_NAME --output-name scores

Stáhněte si výsledek:

ml_client.jobs.download(name=job.name, download_path=".", output_name="scores")

Přečtěte si data s skóre:

import pandas as pd
import glob

output_files = glob.glob("named-outputs/scores/*.csv")
score = pd.concat((pd.read_csv(f) for f in output_files))
score

Výstup vypadá takto:

stáří	...	Thal
0.9338	...	2
1.3782	...	3
1.3782	...	4
-1.954	...	3

Výstup obsahuje předpovědi a data poskytnutá komponentě skóre , která byla předem zpracována. Například sloupec age byl normalizován a sloupec thal obsahuje původní kódovací hodnoty. V praxi pravděpodobně chcete predikci vyvést pouze a pak ji zřetězení s původními hodnotami. Tato práce byla ponechána čtenáři.

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)

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