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

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

• 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í 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:

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

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

   Azure CLI

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

   Python

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

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

   az ml component create -f components/prepare/prepare.yml
   

   Python

   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.

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

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

   Python

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

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

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

Python

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

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

Python

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

az ml job create -f pipeline-job.yml --set inputs.input_data.path=data/unlabeled

Python

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

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

   Python

   endpoint_name = "uci-classifier-score"

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

   Python

   endpoint = BatchEndpoint(
       name=endpoint_name,
       description="Batch scoring endpoint 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.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
   

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

2. Vytvoření 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.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 a jeden literálový vstup.

   Azure CLI

   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
   

   Python

   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.

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, "score_mode": score_mode},
   )

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)

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

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

Python

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áří	Sex	...	thal	předpověď
0.9338	0	...	2	0
1.3782	0	...	3	0
1.3782	0	...	4	0
-1.954	0	...	3	0

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

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)

(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

• 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