Delen via

Een pijplijn implementeren om batchgewijs scoren uit te voeren met voorverwerking

  • Artikel

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

In dit artikel leert u hoe u een deductiepijplijn (of score) implementeert onder een batch-eindpunt. De pijplijn voert scoren uit op een geregistreerd model terwijl er ook een voorverwerkingsonderdeel wordt hergebruikt vanaf het moment dat het model werd getraind. Als u hetzelfde voorverwerkingsonderdeel opnieuw gebruikt, zorgt u ervoor dat dezelfde voorverwerking wordt toegepast tijdens het scoren.

U leert het volgende:

  • Een pijplijn maken die bestaande onderdelen uit de werkruimte hergebruikt
  • De pijplijn implementeren op een eindpunt
  • Voorspellingen gebruiken die zijn gegenereerd door de pijplijn

Over dit voorbeeld

In dit voorbeeld ziet u hoe u voorverwerkingscode en de parameters die zijn geleerd tijdens het vooraf verwerken, opnieuw kunt gebruiken voordat u uw model gebruikt voor deductie. Door de voorverwerkingscode en geleerde parameters opnieuw te gebruiken, kunnen we ervoor zorgen dat dezelfde transformaties (zoals normalisatie en functiecodering) die tijdens de training op de invoergegevens zijn toegepast, ook worden toegepast tijdens deductie. Het model dat wordt gebruikt voor deductie voert voorspellingen uit op tabelgegevens uit de UCI-gegevensset voor hart- en vaatziekten.

Een visualisatie van de pijplijn is als volgt:

Een schermopname van de deductiepijplijn die bestaat uit een scoreonderdeel naast de uitvoer en het voorbereiden van een onderdeel uit een trainingspijplijn.

Het voorbeeld in dit artikel is gebaseerd op codevoorbeelden in de opslagplaats azureml-examples . Als u de opdrachten lokaal wilt uitvoeren zonder YAML en andere bestanden te hoeven kopiëren/plakken, kloont u eerst de opslagplaats en wijzigt u vervolgens mappen in de map:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

De bestanden voor dit voorbeeld bevinden zich in:

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

Volgen in Jupyter-notebooks

U kunt de Python SDK-versie van dit voorbeeld volgen door het notebook sdk-deploy-and-test.ipynb te openen in de gekloonde opslagplaats.

Vereisten

  • Een Azure-abonnement. Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint. Probeer de gratis of betaalde versie van Azure Machine Learning.

  • Een Azure Machine Learning-werkruimte. Zie Azure Machine Learning-werkruimten beheren om een werkruimte te maken.

  • Zorg ervoor dat u de volgende machtigingen hebt in de Machine Learning-werkruimte:

    • Batch-eindpunten en -implementaties maken of beheren: gebruik een eigenaar, inzender of aangepaste rol die dit toestaat Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
    • Azure Resource Manager-implementaties maken in de werkruimteresourcegroep: gebruik een eigenaar, inzender of aangepaste rol waarmee de resourcegroep waarin de werkruimte is geïmplementeerd, is toegestaan Microsoft.Resources/deployments/write .

  • Installeer de volgende software om te werken met Machine Learning:

    Voer de volgende opdracht uit om de Azure CLI en de ml extensie voor Azure Machine Learning te installeren:

    az extension add -n ml

    Implementaties van pijplijnonderdelen voor Batch-eindpunten worden geïntroduceerd in versie 2.7 van de ml extensie voor de Azure CLI. Gebruik de az extension update --name ml opdracht om de nieuwste versie op te halen.

Verbinding maken met uw werkruimte

De werkruimte is de resource op het hoogste niveau voor Machine Learning. Het biedt een centrale plek om te werken met alle artefacten die u maakt wanneer u Machine Learning gebruikt. In deze sectie maakt u verbinding met de werkruimte waar u uw implementatietaken uitvoert.

Voer in de volgende opdracht de waarden in voor uw abonnements-id, werkruimte, locatie en resourcegroep:

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

De deductiepijplijn maken

In deze sectie maken we alle assets die nodig zijn voor onze deductiepijplijn. We beginnen met het maken van een omgeving met de benodigde bibliotheken voor de onderdelen van de pijplijn. Vervolgens maken we een rekencluster waarop de batchimplementatie wordt uitgevoerd. Daarna registreren we de onderdelen, modellen en transformaties die we nodig hebben om onze deductiepijplijn te bouwen. Ten slotte bouwen en testen we de pijplijn.

Maak de omgeving

De onderdelen in dit voorbeeld gebruiken een omgeving met de XGBoost en scikit-learn bibliotheken. Het environment/conda.yml bestand bevat de configuratie van de omgeving:

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

Maak de omgeving als volgt:

  1. Definieer de omgeving:

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

  2. Maak de omgeving:

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

Een rekencluster maken

Batch-eindpunten en -implementaties worden uitgevoerd op rekenclusters. Ze kunnen worden uitgevoerd op elk Azure Machine Learning-rekencluster dat al bestaat in de werkruimte. Daarom kunnen meerdere batchimplementaties dezelfde rekeninfrastructuur delen. In dit voorbeeld werken we aan een Azure Machine Learning-rekencluster met de naam batch-cluster. We gaan controleren of de berekening bestaat in de werkruimte of anders maken.

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Onderdelen en modellen registreren

We gaan onderdelen, modellen en transformaties registreren die we nodig hebben om onze deductiepijplijn te bouwen. We kunnen enkele van deze assets hergebruiken voor trainingsroutines.

Tip

In deze zelfstudie gebruiken we het model en het voorverwerkingsonderdeel van een eerdere trainingspijplijn opnieuw. U kunt zien hoe deze zijn gemaakt door het voorbeeld te volgen hoe u een trainingspijplijn met batch-eindpunten implementeert.

  1. Registreer het model dat moet worden gebruikt voor voorspelling:

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

  2. Het geregistreerde model is niet rechtstreeks getraind op invoergegevens. In plaats daarvan zijn de invoergegevens vooraf verwerkt (of getransformeerd) vóór de training, met behulp van een voorbereidingsonderdeel. We moeten dit onderdeel ook registreren. Registreer het voorbereidingsonderdeel:

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

    Tip

    Nadat u het voorbereidingsonderdeel hebt geregistreerd, kunt u er nu vanuit de werkruimte naar verwijzen. Hiermee krijgt u bijvoorbeeld azureml:uci_heart_prepare@latest de laatste versie van het voorbereidingsonderdeel.

  3. Als onderdeel van de gegevenstransformaties in het voorbereidingsonderdeel zijn de invoergegevens genormaliseerd om de voorspellers te centreren en hun waarden te beperken in het bereik van [-1, 1]. De transformatieparameters zijn vastgelegd in een scikit-learn-transformatie die we ook kunnen registreren om later toe te passen wanneer we nieuwe gegevens hebben. Registreer de transformatie als volgt:

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

  4. We voeren deductie uit voor het geregistreerde model, met behulp van een ander onderdeel met de naam score waarmee de voorspellingen voor een bepaald model worden berekend. We verwijzen rechtstreeks vanuit de definitie naar het onderdeel.

    Tip

    Het is raadzaam om het onderdeel te registreren en ernaar te verwijzen vanuit de pijplijn. In dit voorbeeld verwijzen we echter rechtstreeks vanuit de definitie naar het onderdeel, zodat u kunt zien welke onderdelen opnieuw worden gebruikt vanuit de trainingspijplijn en welke onderdelen nieuw zijn.

De pijplijn bouwen

Nu is het tijd om alle elementen met elkaar te verbinden. De deductiepijplijn die we gaan implementeren, bevat twee onderdelen (stappen):

  • preprocess_job: Deze stap leest de invoergegevens en retourneert de voorbereide gegevens en de toegepaste transformaties. De stap ontvangt twee invoerwaarden:
    • data: een map met de invoergegevens om te scoren
    • transformations: (optioneel) Pad naar de transformaties die worden toegepast, indien beschikbaar. Wanneer deze zijn opgegeven, worden de transformaties gelezen uit het model dat wordt aangegeven op het pad. Als het pad echter niet is opgegeven, worden de transformaties geleerd van de invoergegevens. Voor deductie kunt u echter niet de transformatieparameters (in dit voorbeeld de normalisatiecoëfficiënten) van de invoergegevens leren, omdat u dezelfde parameterwaarden moet gebruiken die tijdens de training zijn geleerd. Omdat deze invoer optioneel is, kan het onderdeel worden gebruikt tijdens het preprocess_job trainen en scoren.
  • score_job: Met deze stap wordt deductie uitgevoerd op de getransformeerde gegevens met behulp van het invoermodel. U ziet dat het onderdeel gebruikmaakt van een MLflow-model om deductie uit te voeren. Ten slotte worden de scores teruggeschreven in dezelfde indeling als ze werden gelezen.

De pijplijnconfiguratie is gedefinieerd in het pipeline.yml bestand:

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

Een visualisatie van de pijplijn is als volgt:

Een schermopname van de deductiepijplijn met batchgewijs scoren met voorverwerking.

De pijplijn testen

We gaan de pijplijn testen met enkele voorbeeldgegevens. Hiervoor maken we een taak met behulp van de pijplijn en het batch-cluster rekencluster dat eerder is gemaakt.

Het volgende pipeline-job.yml bestand bevat de configuratie voor de pijplijntaak:

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

Maak de testtaak:

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

Een batch-eindpunt maken

  1. Geef een naam op voor het eindpunt. De naam van een batch-eindpunt moet uniek zijn in elke regio, omdat de naam wordt gebruikt om de aanroep-URI samen te stellen. Voeg eventuele volgtekens toe aan de naam die in de volgende code is opgegeven om de uniekheid te garanderen.

    ENDPOINT_NAME="uci-classifier-score"

  2. Configureer het eindpunt:

    Het endpoint.yml bestand bevat de configuratie van het eindpunt.

    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

  3. Maak het eindpunt:

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

  4. Voer een query uit op de eindpunt-URI:

    az ml batch-endpoint show --name $ENDPOINT_NAME

Het pijplijnonderdeel implementeren

Om het pijplijnonderdeel te implementeren, moeten we een batchimplementatie maken. Een implementatie is een set resources die vereist is voor het hosten van de asset die het werkelijke werk uitvoert.

  1. De implementatie configureren

    Het deployment.yml bestand bevat de configuratie van de implementatie. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.

    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

  2. De implementatie maken

    Voer de volgende code uit om een batch-implementatie te maken onder het batch-eindpunt en deze in te stellen als de standaardimplementatie.

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

    Tip

    Let op het gebruik van de --set-default vlag om aan te geven dat deze nieuwe implementatie nu de standaardwaarde is.

  3. Uw implementatie is klaar voor gebruik.

De implementatie testen

Zodra de implementatie is gemaakt, kunt u taken ontvangen. Volg deze stappen om deze te testen:

  1. Voor onze implementatie moeten we één gegevensinvoer en één letterlijke invoer aangeven.

    Het inputs.yml bestand bevat de definitie voor de invoergegevensasset:

    inputs.yml

    inputs:
  input_data:
    type: uri_folder
    path: data/unlabeled
  score_mode:
    type: string
    default: append
outputs:
  scores:
    type: uri_folder
    mode: upload

    Tip

    Zie Taken en invoergegevens maken voor batcheindpunten voor meer informatie over het aangeven van invoer.

  2. U kunt de standaardimplementatie als volgt aanroepen:

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

  3. U kunt de voortgang van de voorstelling controleren en de logboeken streamen met behulp van:

    az ml job stream -n $JOB_NAME

Uitvoer van Access-taak

Zodra de taak is voltooid, hebben we toegang tot de uitvoer. Deze taak bevat slechts één uitvoer met de naam scores:

U kunt de bijbehorende resultaten downloaden met behulp van az ml job download.

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

Lees de gescoorde gegevens:

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

De uitvoer ziet er als volgt uit:

leeftijd geslacht ... thal voorspelling
0.9338 1 ... 2 0
1.3782 1 ... 3 1
1.3782 1 ... 4 0
-1.954 1 ... 3 0

De uitvoer bevat de voorspellingen plus de gegevens die zijn opgegeven voor het scoreonderdeel , dat vooraf is verwerkt. De kolom age is bijvoorbeeld genormaliseerd en de kolom thal bevat oorspronkelijke coderingswaarden. In de praktijk wilt u waarschijnlijk alleen de voorspelling uitvoeren en deze vervolgens samenvoegen met de oorspronkelijke waarden. Dit werk is aan de lezer overgelaten.

Resources opschonen

Wanneer u klaar bent, verwijdert u de gekoppelde resources uit de werkruimte:

Voer de volgende code uit om het batch-eindpunt en de onderliggende implementatie te verwijderen. --yes wordt gebruikt om de verwijdering te bevestigen.

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

(Optioneel) Verwijder rekenkracht, tenzij u van plan bent om uw rekencluster opnieuw te gebruiken met latere implementaties.

az ml compute delete -n batch-cluster

Volgende stappen