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 inference (nebo scoring) pipeline v rámci dávkového koncového bodu. Kanál provádí vyhodnocení nad registrovaným modelem a zároveň opakovaně používá komponentu předběžného zpracování použitou během trénování 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řte pipeline, 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 datovým tokem

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.

Zobrazení pipeline 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 prohlížet otevřením notebooku 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 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 vytvoření nebo správu dávkových koncových bodů a nasazení použijte roli vlastníka, přispěvatele nebo vlastní roli, která má oprávnění Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
  • Pro vytváření nasazení v Azure Resource Manageru ve skupině prostředků pracovního prostoru použijte roli Vlastník, Přispěvatel nebo Vlastní role, která má Microsoft.Resources/deployments/write oprávnění ve skupině prostředků, kde 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 mlrozšíření pro Azure Machine Learning:

  az extension add -n ml
  

  Nasazení komponent kanálu pro dávkové koncové body vyžadují rozšíření ml pro Azure CLI ve verzi 2.7 nebo novější (aktuální verze: 2.37.0). 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 vyžadují sadu SDK verze 1.7.0 nebo novější (aktuální verze: 1.32.0). 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, kde provádíte úkony související s nasazením.

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 ukazatel 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 knihovnami XGBoost a scikit-learn. Soubor environment/conda.yml obsahuje konfiguraci prostředí:

environment/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-ubuntu22.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. Ověřme, zda výpočetní zdroje existují v pracovním prostoru, nebo je jinak vytvoříme.

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.

Návod

V tomto tutoriálu znovu použijeme model a komponentu předzpracování z dřívějšího trénovacího procesu. Podle příkladu Jak nasadit tréninkovou pipeline s batch endpointy 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 byla vstupní data předzpracována (nebo transformována) před trénováním pomocí komponenty pro přípravu. 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)

   Návod

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

3. V rámci datových transformací v komponentě pro přípravu byla vstupní data normalizována, aby se prediktory zacentrovaly a jejich hodnoty byly omezeny na rozsah [-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.

   Návod

   Osvědčeným postupem je zaregistrovat komponentu a odkazovat na ni z pipeline. 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 není zadána cesta, transformace se naučí ze vstupních dat. 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 v souboru pipeline.yml:

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}

Zobrazení pipeline je následující:

Otestování kanálu

Otestujme potrubí pomocí ukázkových dat. K tomu vytvoříme úlohu pomocí pipeline a výpočetního clusteru, které byly vytvořeny dříve batch-cluster.

Azure CLI

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

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řte dávkový koncový bod

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í URI volá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 pipeline, 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áš zpracovávací řetězec je definován ve funkci. Pokud ho chcete transformovat na komponentu, použijete vlastnost component z ní. 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ř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.yml --set-default
   

   Návod

   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 implementace je připraveno k použití.

Testujte nasazení

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

1. Naše nasazení vyžaduje, abychom označili jeden vstup dat a jeden textový 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 objektu:

   input_data = Input(type="uri_folder", path="data/unlabeled/")
   score_mode = Input(type="string", default="append")

   Návod

   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

   Návod

   Jaký je rozdíl mezi parametrem inputs a parametrem input, když vyvoláte koncový bod?

   Obecně můžete pomocí parametru slovníku inputs = {} s metodou invoke poskytnout libovolný počet vstupů požadovaných 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. Sledovat můžete průběh aplikace a streamovat protokoly 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)

Přístup k výstupu úlohy

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 ohodnocená data.

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	predikce
0.9338	1	...	2	0
1.3782	1	...	3	1
1.3782	1	...	4	0
-1.954	1	...	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 pouze vyvést predikci a pak ji zřetězit s původními hodnotami. Tato práce byla ponechána čtenáři.

Uvolně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 v rámci potrubí
• Přístup k datům z úloh dávkových koncových bodů
• Řešení potíží s dávkovými koncovými body