Så här distribuerar du en pipeline för att utföra batchbedömning med förbearbetning

GÄLLER FÖR:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (aktuell)

I den här artikeln får du lära dig hur du distribuerar en slutsatsdragningspipeline (eller bedömning) under en batchslutpunkt. Pipelinen utför bedömning över en registrerad modell samtidigt som en förbearbetningskomponent återanvänds från när modellen tränades. Om du återanvänder samma förbearbetningskomponent ser du till att samma förbearbetning tillämpas under bedömning.

Du lär dig att:

• Skapa en pipeline som återanvänder befintliga komponenter från arbetsytan
• Distribuera pipelinen till en slutpunkt
• Använda förutsägelser som genereras av pipelinen

Om det här exemplet

Det här exemplet visar hur du återanvänder förbearbetningskod och de parametrar som du lärde dig under förbearbetningen innan du använder din modell för slutsatsdragning. Genom att återanvända förbearbetningskoden och inlärda parametrar kan vi se till att samma transformeringar (till exempel normalisering och funktionskodning) som tillämpades på indata under träningen också tillämpas under inferensen. Modellen som används för slutsatsdragning utför förutsägelser på tabelldata från datauppsättningen för UCI-hjärtsjukdomar.

En visualisering av pipelinen är följande:

Exemplet i den här artikeln baseras på kodexempel som finns på lagringsplatsen azureml-examples . Om du vill köra kommandona lokalt utan att behöva kopiera/klistra in YAML och andra filer klonar du först lagringsplatsen och ändrar sedan kataloger till mappen:

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

Filerna för det här exemplet finns i:

cd endpoints/batch/deploy-pipelines/batch-scoring-with-preprocessing

Följ med i Jupyter Notebooks

Du kan följa med i Python SDK-versionen av det här exemplet genom att öppna notebook-filen sdk-deploy-and-test.ipynb på den klonade lagringsplatsen.

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Mašinsko učenje.

• En Azure Machine Learning-arbetsyta. Information om hur du skapar en arbetsyta finns i Hantera Azure Mašinsko učenje-arbetsytor.

• Kontrollera att du har följande behörigheter på Mašinsko učenje-arbetsytan:

  • Skapa eller hantera batchslutpunkter och distributioner: Använd en ägare, deltagare eller anpassad roll som tillåter Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
  • Skapa Azure Resource Manager-distributioner i arbetsytans resursgrupp: Använd en roll som ägare, deltagare eller anpassad som tillåter Microsoft.Resources/deployments/write i den resursgrupp där arbetsytan distribueras.

• Installera följande programvara för att arbeta med Mašinsko učenje:

  Azure CLI

  Kör följande kommando för att installera Azure CLI och ml tillägget för Azure Mašinsko učenje:

  az extension add -n ml
  

  Distributioner av pipelinekomponenter för Batch-slutpunkter introduceras i version 2.7 av ml tillägget för Azure CLI. az extension update --name ml Använd kommandot för att hämta den senaste versionen.

  Python

  Kör följande kommando för att installera Azure Mašinsko učenje SDK för Python:

  pip install azure-ai-ml
  

  Klasserna ModelBatchDeployment och PipelineComponentBatchDeployment introduceras i version 1.7.0 av SDK:et. pip install -U azure-ai-ml Använd kommandot för att hämta den senaste versionen.

---

Anslut till din arbetsyta

Arbetsytan är resursen på den översta nivån för Mašinsko učenje. Den ger en central plats där du kan arbeta med alla artefakter som du skapar när du använder Mašinsko učenje. I det här avsnittet ansluter du till arbetsytan där du utför dina distributionsuppgifter.

Azure CLI

I följande kommando anger du värdena för ditt prenumerations-ID, arbetsyta, plats och resursgrupp:

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

Python

1. Importera de bibliotek som krävs:

   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. Konfigurera arbetsytans information och få ett handtag till arbetsytan:

   I följande kommando anger du värdena för ditt prenumerations-ID, arbetsyta och resursgrupp:

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

Skapa slutsatsdragningspipelinen

I det här avsnittet skapar vi alla tillgångar som krävs för vår slutsatsdragningspipeline. Vi börjar med att skapa en miljö som innehåller nödvändiga bibliotek för pipelinens komponenter. Nu ska vi skapa ett beräkningskluster där batchdistributionen ska köras. Efteråt registrerar vi de komponenter, modeller och transformeringar som vi behöver för att skapa vår slutsatsdragningspipeline. Slutligen ska vi skapa och testa pipelinen.

Skapa miljön

Komponenterna i det här exemplet använder en miljö med biblioteken XGBoost och scikit-learn . Filen environment/conda.yml innehåller miljöns konfiguration:

miljö/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

Skapa miljön på följande sätt:

1. Definiera miljön:

   Azure CLI

   miljö/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. Skapa miljön:

   Azure CLI

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

   Python

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

Skapa ett beräkningskluster

Batchslutpunkter och distributioner körs på beräkningskluster. De kan köras på valfritt Azure-Mašinsko učenje beräkningskluster som redan finns på arbetsytan. Därför kan flera batchdistributioner dela samma beräkningsinfrastruktur. I det här exemplet ska vi arbeta med ett Azure Mašinsko učenje beräkningskluster med namnet batch-cluster. Nu ska vi kontrollera att beräkningen finns på arbetsytan eller skapa den på annat sätt.

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

Registrera komponenter och modeller

Vi ska registrera komponenter, modeller och transformeringar som vi behöver för att bygga vår slutsatsdragningspipeline. Vi kan återanvända några av dessa tillgångar för träningsrutiner.

Dricks

I den här självstudien återanvänder vi modellen och förbearbetningskomponenten från en tidigare träningspipeline. Du kan se hur de skapades genom att följa exemplet Så här distribuerar du en träningspipeline med batchslutpunkter.

1. Registrera modellen som ska användas för förutsägelse:

   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. Den registrerade modellen tränades inte direkt på indata. I stället förbearbetades indata (eller transformerades) före träningen med hjälp av en förberedelsekomponent. Vi måste också registrera den här komponenten. Registrera förberedelsekomponenten:

   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)

   Dricks

   När du har registrerat förberedelsekomponenten kan du nu referera till den från arbetsytan. Till exempel azureml:uci_heart_prepare@latest hämtar den sista versionen av förberedelsekomponenten.

3. Som en del av datatransformeringarna i förberedelsekomponenten normaliserades indata för att centrera prediktorerna och begränsa deras värden i intervallet [-1, 1]. Transformeringsparametrarna hämtades i en scikit-learn-transformering som vi också kan registrera för att tillämpas senare när vi har nya data. Registrera omvandlingen på följande sätt:

   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. Vi ska utföra slutsatsdragning för den registrerade modellen med hjälp av en annan komponent med namnet score som beräknar förutsägelserna för en viss modell. Vi refererar till komponenten direkt från dess definition.

   Dricks

   Bästa praxis är att registrera komponenten och referera till den från pipelinen. I det här exemplet ska vi dock referera till komponenten direkt från dess definition för att hjälpa dig att se vilka komponenter som återanvänds från träningspipelinen och vilka som är nya.

Skapa pipelinen

Nu är det dags att binda samman alla element. Den slutsatsdragningspipeline som vi distribuerar har två komponenter (steg):

• preprocess_job: Det här steget läser indata och returnerar förberedda data och tillämpade transformeringar. Steget tar emot två indata:
  • data: en mapp som innehåller de indata som ska poängsättas
  • transformations: (valfritt) Sökväg till de transformeringar som ska tillämpas, om det är tillgängligt. När de tillhandahålls läss transformeringarna från modellen som anges på sökvägen. Men om sökvägen inte tillhandahålls kommer transformeringarna att läras från indata. För slutsatsdragning kan du dock inte lära dig transformeringsparametrarna (i det här exemplet normaliseringskoefficienterna) från indata eftersom du behöver använda samma parametervärden som lärdes under träningen. Eftersom den här indatan är valfri kan komponenten preprocess_job användas under träning och bedömning.
• score_job: Det här steget kommer att utföra slutsatsdragning på transformerade data med hjälp av indatamodellen. Observera att komponenten använder en MLflow-modell för att utföra slutsatsdragning. Slutligen skrivs poängen tillbaka i samma format som de lästes.

Azure CLI

Pipelinekonfigurationen definieras i pipeline.yml filen:

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

Nu ska vi skapa pipelinen i en funktion:

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

En visualisering av pipelinen är följande:

Testa pipelinen

Nu ska vi testa pipelinen med några exempeldata. För att göra det skapar vi ett jobb med hjälp av pipelinen och batch-cluster beräkningsklustret som skapades tidigare.

Azure CLI

Följande pipeline-job.yml fil innehåller konfigurationen för pipelinejobbet:

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

Nu ska vi konfigurera några körningsinställningar för att köra testet:

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

Skapa testjobbet:

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

Skapa en batchslutpunkt

1. Ange ett namn för slutpunkten. Namnet på en batchslutpunkt måste vara unikt i varje region eftersom namnet används för att konstruera anrops-URI:n. För att säkerställa unikhet lägger du till eventuella avslutande tecken i det namn som anges i följande kod.

   Azure CLI

   ENDPOINT_NAME="uci-classifier-score"
   

   Python

   endpoint_name = "uci-classifier-score"

2. Konfigurera slutpunkten:

   Azure CLI

   Filen endpoint.yml innehåller slutpunktens konfiguration.

   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. Skapa slutpunkten:

   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. Fråga slutpunkts-URI:n:

   Azure CLI

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

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

Distribuera pipelinekomponenten

För att distribuera pipelinekomponenten måste vi skapa en batchdistribution. En distribution är en uppsättning resurser som krävs för att vara värd för den tillgång som utför det faktiska arbetet.

1. Konfigurera distributionen

   Azure CLI

   Filen deployment.yml innehåller distributionens konfiguration. Du kan kontrollera YAML-schemat för den fullständiga batchslutpunkten för extra egenskaper.

   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

   Vår pipeline definieras i en funktion. Om du vill omvandla den till en komponent använder du egenskapen från den component . Pipelinekomponenter är återanvändbara beräkningsdiagram som kan ingå i batchdistributioner eller användas för att skapa mer komplexa pipelines.

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

   Nu kan vi definiera distributionen:

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

   Azure CLI

   Kör följande kod för att skapa en batchdistribution under batchslutpunkten och ange den som standarddistribution.

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

   Dricks

   Observera att flaggan används --set-default för att ange att den nya distributionen nu är standard.

   Python

   Det här kommandot startar distributionen och returnerar ett bekräftelsesvar medan distributionen skapas.

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

   När vi har skapat den här nya distributionen ska vi konfigurera den som standard:

   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. Distributionen är klar för användning.

Testa distributionen

När distributionen har skapats är den redo att ta emot jobb. Följ dessa steg för att testa det:

1. Distributionen kräver att vi anger en datainmatning och en literalinmatning.

   Azure CLI

   Filen inputs.yml innehåller definitionen för indatatillgången:

   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

   Indatatillgångsdefinitionen:

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

   Dricks

   Mer information om hur du anger indata finns i Skapa jobb och indata för batchslutpunkter.

2. Du kan anropa standarddistributionen på följande sätt:

   Azure CLI

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

   Python

   Dricks

   Vad är skillnaden mellan parametern inputs och input när du anropar en slutpunkt?

   I allmänhet kan du använda en ordlisteparameter inputs = {} med invoke metoden för att ange ett godtyckligt antal obligatoriska indata till en batchslutpunkt som innehåller en modelldistribution eller en pipelinedistribution.

   För en modelldistribution kan du använda parametern input som ett kortare sätt att ange indataplatsen för distributionen. Den här metoden fungerar eftersom en modelldistribution alltid bara tar en datainmatning.

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

3. Du kan övervaka förloppet för showen och strömma loggarna med hjälp av:

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Kör följande kod för att vänta tills jobbet har slutförts:

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

Få åtkomst till jobbutdata

När jobbet har slutförts kan vi komma åt dess utdata. Det här jobbet innehåller bara ett utdata med namnet scores:

Azure CLI

Du kan ladda ned de associerade resultaten med hjälp av az ml job download.

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

Python

Ladda ned resultatet:

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

Läs poängsatta 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

Utdata ser ut så här:

ålder	Sex	...	thal	prognos
0.9338	1	...	2	0
1.3782	1	...	3	1
1.3782	1	...	4	0
-1.954	1	...	3	0

Utdata innehåller förutsägelserna plus de data som angavs för poängkomponenten , som var förbearbetad. Kolumnen age har till exempel normaliserats och kolumnen thal innehåller ursprungliga kodningsvärden. I praktiken vill du förmodligen bara mata ut förutsägelsen och sedan sammanfoga den med de ursprungliga värdena. Det här arbetet har lämnats till läsaren.

Rensa resurser

När du är klar tar du bort de associerade resurserna från arbetsytan:

Azure CLI

Kör följande kod för att ta bort batchslutpunkten och dess underliggande distribution. --yes används för att bekräfta borttagningen.

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

Python

Ta bort slutpunkten:

ml_client.batch_endpoints.begin_delete(endpoint_name)

(Valfritt) Ta bort beräkning, såvida du inte planerar att återanvända beräkningsklustret med senare distributioner.

Azure CLI

az ml compute delete -n batch-cluster

Python

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

Nästa steg

• Skapa batchslutpunkter från pipelinejobb
• Komma åt data från batchslutpunktsjobb
• Felsöka batchslutpunkter