Dela via

Distribuera modeller för bedömning i batchslutpunkter

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

Med Batch-slutpunkter kan du distribuera modeller som kör slutsatsdragning över stora mängder data. Dessa slutpunkter förenklar värdmodeller för batchbedömning, så att du kan fokusera på maskininlärning i stället för infrastruktur.

Använd batchslutpunkter för att distribuera modeller när:

  • Du använder dyra modeller som tar längre tid att köra slutsatsdragning.
  • Du kan dra slutsatser om stora mängder data som distribueras i flera filer.
  • Du behöver inte korta svarstider.
  • Du kan dra nytta av parallellisering.

Den här artikeln visar hur du använder en batchslutpunkt för att distribuera en maskininlärningsmodell som löser det klassiska MNIST-igenkänningsproblemet (Modified National Institute of Standards and Technology). Den distribuerade modellen utför batchinferens över stora mängder data, till exempel bildfiler. Processen börjar med att skapa en batchdistribution av en modell som skapats med Torch. Den här distributionen blir standard i endpoint. Skapa senare en andra distribution av en modell som skapats med TensorFlow (Keras), testa den andra distributionen och ange den som slutpunktens standarddistribution.

Förutsättningar

Innan du följer stegen i den här artikeln kontrollerar du att du har följande förutsättningar:

Klona exempellagringsplatsen

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:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli/endpoints/batch/deploy-models/mnist-classifier

Förbereda systemet

Anslut till din arbetsyta

Anslut först till Azure Machine Learning-arbetsytan där du arbetar.

Om du inte redan har angett standardinställningarna för Azure CLI sparar du standardinställningarna. Kör den här koden för att undvika att ange värdena för din prenumeration, arbetsyta, resursgrupp och plats flera gånger:

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

Skapa beräkning

Batchslutpunkter körs på beräkningskluster och stöder både Azure Machine Learning-beräkningskluster (AmlCompute) och Kubernetes-kluster. Kluster är en delad resurs, därför kan ett kluster vara värd för en eller flera batchdistributioner (tillsammans med andra arbetsbelastningar, om så önskas).

Skapa en beräkning med namnet batch-cluster, enligt följande kod. Justera efter behov och referera till din beräkning med hjälp av azureml:<your-compute-name>.

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

Kommentar

Du debiteras inte för beräkningen just nu eftersom klustret ligger kvar på 0 noder tills en batchslutpunkt anropas och ett batchbedömningsjobb skickas. Mer information om beräkningskostnader finns i Hantera och optimera kostnaden för AmlCompute.

Skapa en batchslutpunkt

En batchslutpunkt är en HTTPS-slutpunkt som klienter anropar för att utlösa ett batchbedömningsjobb. Ett batchbedömningsjobb bearbetar flera indata. En batchdistribution är en uppsättning beräkningsresurser som är värdar för modellen som utför batchbedömning (eller batchinferens). En batchslutpunkt kan ha flera batchdistributioner. Mer information om batchslutpunkter finns i Vad är batchslutpunkter?.

Dricks

En av batchdistributionerna fungerar som standarddistribution för slutpunkten. När slutpunkten anropas utför standarddistributionen batchbedömning. Mer information om batchslutpunkter och distributioner finns i batchslutpunkter och batchdistribution.

  1. Namnge slutpunkten. Slutpunktens namn måste vara unikt i en Azure-region eftersom namnet ingår i slutpunktens URI. Det kan till exempel bara finnas en batchslutpunkt med namnet mybatchendpoint i westus2.

    Placera slutpunktens namn i en variabel för att enkelt referera till den senare.

    ENDPOINT_NAME="mnist-batch"

  2. Konfigurera batchslutpunkten

    Följande YAML-fil definierar en batchslutpunkt. Använd den här filen med CLI-kommandot för att skapa batchslutpunkter.

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: mnist-batch
description: A batch endpoint for scoring images from the MNIST dataset.
tags:
  type: deep-learning

    I följande tabell beskrivs nyckelegenskaperna för slutpunkten. Det fullständiga YAML-schemat för batchslutpunkten finns i CLI(v2) YAML-schema för batchslutpunkt.

    Nyckel beskrivning
    name Namnet på batchslutpunkten. Måste vara unikt på Azure-regionnivå.
    description Beskrivningen av batchslutpunkten. Den här egenskapen är valfri.
    tags Taggarna som ska inkluderas i slutpunkten. Den här egenskapen är valfri.

  3. Skapa slutpunkten:

    Kör den här koden för att skapa en batchslutpunkt.

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

Skapa en batchdistribution

En modelldistribution är en uppsättning resurser som krävs för att vara värd för den modell som utför den faktiska inferensen. Om du vill skapa en distribution av en batchmodell behöver du följande:

  • En registrerad modell på arbetsytan
  • Koden för att poängsätta modellen
  • En miljö med modellens beroenden installerade
  • De förskapade inställningarna för beräkning och resurser

  1. Börja med att registrera den modell som ska distribueras – en Torch-modell för det populära problemet med sifferigenkänning (MNIST). Batch-distributioner kan bara distribuera modeller som är registrerade på arbetsytan. Du kan hoppa över det här steget om den modell som du vill distribuera redan är registrerad.

    Dricks

    Modeller är associerade med distributionen i stället för med slutpunkten. Det innebär att en enskild slutpunkt kan hantera olika modeller (eller modellversioner) under samma slutpunkt så länge de olika modellerna (eller modellversionerna) distribueras i olika distributioner.

    MODEL_NAME='mnist-classifier-torch'
az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"

  2. Nu är det dags att skapa ett bedömningsskript. Batchdistributioner kräver ett bedömningsskript som anger hur en viss modell ska köras och hur indata måste bearbetas. Batch-slutpunkter stöder skript som skapats i Python. I det här fallet distribuerar du en modell som läser bildfiler som representerar siffror och matar ut motsvarande siffra. Bedömningsskriptet är följande:

    Kommentar

    För MLflow-modeller genererar Azure Machine Learning automatiskt bedömningsskriptet, så du behöver inte ange något. Om din modell är en MLflow-modell kan du hoppa över det här steget. Mer information om hur batchslutpunkter fungerar med MLflow-modeller finns i artikeln Använda MLflow-modeller i batchdistributioner.

    Varning

    Om du distribuerar en AutoML-modell (Automatiserad maskininlärning) under en batchslutpunkt bör du tänka på att bedömningsskriptet som AutoML endast tillhandahåller fungerar för onlineslutpunkter och inte är utformat för batchkörning. Information om hur du skapar ett bedömningsskript för batchdistributionen finns i Skapa bedömningsskript för batchdistributioner.

    deployment-torch/code/batch_driver.py

    import os
import pandas as pd
import torch
import torchvision
import glob
from os.path import basename
from mnist_classifier import MnistClassifier
from typing import List


def init():
    global model
    global device

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder
    model_path = os.environ["AZUREML_MODEL_DIR"]
    model_file = glob.glob(f"{model_path}/*/*.pt")[-1]

    model = MnistClassifier()
    model.load_state_dict(torch.load(model_file))
    model.eval()

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    with torch.no_grad():
        for image_path in mini_batch:
            image_data = torchvision.io.read_image(image_path).float()
            batch_data = image_data.expand(1, -1, -1, -1)
            input = batch_data.to(device)

            # perform inference
            predict_logits = model(input)

            # Compute probabilities, classes and labels
            predictions = torch.nn.Softmax(dim=-1)(predict_logits)
            predicted_prob, predicted_class = torch.max(predictions, axis=-1)

            results.append(
                {
                    "file": basename(image_path),
                    "class": predicted_class.numpy()[0],
                    "probability": predicted_prob.numpy()[0],
                }
            )

    return pd.DataFrame(results)

  3. Skapa en miljö där batchdistributionen körs. Miljön bör innehålla paketen azureml-core och azureml-dataset-runtime[fuse], som krävs av batchslutpunkter, plus eventuella beroenden som koden kräver för att köras. I det här fallet har beroendena avbildats i en conda.yaml fil:

    deployment-torch/environment/conda.yaml

    name: mnist-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip<22.0
  - pip:
    - torch==1.13.0
    - torchvision==0.14.0
    - pytorch-lightning
    - pandas
    - azureml-core
    - azureml-dataset-runtime[fuse]

    Viktigt!

    Paketen azureml-core och azureml-dataset-runtime[fuse] krävs av batchdistributioner och bör ingå i miljöberoendena.

    Ange miljön enligt följande:

    Miljödefinitionen ingår i själva distributionsdefinitionen som en anonym miljö. Du ser följande rader i distributionen:

    environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

  4. Gå till fliken Miljöer på sidomenyn.

  5. Välj Skapa anpassade miljöer>.

    1. Ange namnet på miljön, i det här fallet torch-batch-env.

    2. För Välj miljökälla väljer du Använd befintlig docker-avbildning med valfri conda-fil.

    3. För sökvägen containerregisteravbildning anger du mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.

    4. Välj Nästa för att gå till avsnittet "Anpassa".

    5. Kopiera innehållet i filen deployment-torch/environment/conda.yaml från GitHub-lagringsplatsen till portalen.

  6. Välj Nästa tills du når sidan Granska.

  7. Välj Skapa och vänta tills miljön är klar.

    Varning

    Utvalda miljöer stöds inte i batchdistributioner. Du måste ange din egen miljö. Du kan alltid använda basavbildningen av en kurerad miljö som din för att förenkla processen.

  8. Skapa en distributionsdefinition

    deployment-torch/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
name: mnist-torch-dpl
description: A deployment using Torch to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model:
  name: mnist-classifier-torch
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 30
  error_threshold: -1
  logging_level: info

    I följande tabell beskrivs de viktigaste egenskaperna för batchdistributionen. Det fullständiga YAML-schemat för batchdistribution finns i YAML-schema för CLI-batchdistribution (v2).

    Nyckel beskrivning
    name Namnet på distributionen.
    endpoint_name Namnet på slutpunkten som distributionen ska skapas under.
    model Den modell som ska användas för batchbedömning. Exemplet definierar en infogad modell med hjälp av path. Den här definitionen tillåter att modellfiler laddas upp och registreras automatiskt med ett automatiskt genererat namn och en version. Se modellschemat för fler alternativ. Som bästa praxis för produktionsscenarier bör du skapa modellen separat och referera till den här. Om du vill referera till en befintlig modell använder du syntaxen azureml:<model-name>:<model-version> .
    code_configuration.code Den lokala katalogen som innehåller all Python-källkod för att poängsätta modellen.
    code_configuration.scoring_script Python-filen i code_configuration.code katalogen. Den här filen måste ha en init() funktion och en run() funktion. init() Använd funktionen för alla kostsamma eller vanliga förberedelser (till exempel för att läsa in modellen i minnet). init() anropas bara en gång i början av processen. Använd run(mini_batch) för att poängsätta varje post. Värdet mini_batch för är en lista med filsökvägar. Funktionen run() ska returnera en Pandas DataFrame eller en matris. Varje returnerat element anger en lyckad körning av indataelementet mini_batchi . Mer information om hur du skapar ett bedömningsskript finns i Förstå bedömningsskriptet.
    environment Miljön för att poängsätta modellen. I exemplet definieras en infogad miljö med hjälp av conda_file och image. Beroendena conda_file installeras ovanpå image. Miljön registreras automatiskt med ett automatiskt genererat namn och en version. Se miljöschemat för fler alternativ. Som bästa praxis för produktionsscenarier bör du skapa miljön separat och referera till den här. Om du vill referera till en befintlig miljö använder du syntaxen azureml:<environment-name>:<environment-version> .
    compute Den beräkning som ska köra batchbedömning. Exemplet använder den batch-cluster som skapades i början och refererar till den med hjälp av syntaxen azureml:<compute-name> .
    resources.instance_count Antalet instanser som ska användas för varje batchbedömningsjobb.
    settings.max_concurrency_per_instance Det maximala antalet parallella scoring_script körningar per instans.
    settings.mini_batch_size Antalet filer som kan bearbetas scoring_script i ett run() anrop.
    settings.output_action Hur utdata ska ordnas i utdatafilen. append_row sammanfogar alla run() returnerade utdataresultat till en enda fil med namnet output_file_name. summary_only sammanfogar inte utdataresultaten och beräknar error_thresholdbara .
    settings.output_file_name Namnet på batchbedömningsutdatafilen för append_rowoutput_action.
    settings.retry_settings.max_retries Antalet maximala försök för en misslyckad scoring_scriptrun().
    settings.retry_settings.timeout Tidsgränsen i sekunder för en scoring_scriptrun() för bedömning av en minibatch.
    settings.error_threshold Antalet fel i indatafilens bedömning som ska ignoreras. Om felantalet för hela indata överskrider det här värdet avslutas batchbedömningsjobbet. I exemplet används -1, vilket anger att valfritt antal fel tillåts utan att batchbedömningsjobbet avslutas.
    settings.logging_level Loggdetaljeringsgrad. Värden i ökande verbositet är: WARNING, INFO och DEBUG.
    settings.environment_variables Ordlista över miljövariabelns namn/värde-par som ska anges för varje batchbedömningsjobb.

  9. Gå till fliken Slutpunkter på sidomenyn.

    1. Välj fliken Batch-slutpunkter>Skapa.

    2. Ge slutpunkten ett namn, i det här fallet mnist-batch. Du kan konfigurera resten av fälten eller lämna dem tomma.

    3. Välj Nästa för att gå till avsnittet "Modell".

    4. Välj modellen mnist-classifier-torch.

    5. Välj Nästa för att gå till sidan "Distribution".

    6. Ge distributionen ett namn.

  10. Kontrollera att Lägg till rad är vald för åtgärden Utdata.

    1. För Namn på utdatafil kontrollerar du att utdatafilen för batchbedömning är den du behöver. Standard är predictions.csv.

    2. För minibatchstorlek justerar du storleken på de filer som ska ingå i varje mini-batch. Den här storleken styr mängden data som ditt bedömningsskript tar emot per batch.

    3. Se till att du ger tillräckligt med tid för distributionen för att poängsätta en viss uppsättning filer för bedömning av tidsgränsen (sekunder). Om du ökar antalet filer måste du vanligtvis också öka tidsgränsvärdet. Dyrare modeller (som de som baseras på djupinlärning) kan kräva höga värden i det här fältet.

    4. För Maximal samtidighet per instans konfigurerar du det antal utförare som du vill ha för varje beräkningsinstans som du får i distributionen. Ett högre tal här garanterar en högre grad av parallellisering, men det ökar också minnesbelastningen på beräkningsinstansen. Justera det här värdet helt och hållet med mini batchstorlek.

    5. När du är klar väljer du Nästa för att gå till sidan Kod + miljö.

    6. För "Välj ett bedömningsskript för slutsatsdragning" bläddrar du för att hitta och väljer bedömningsskriptfilen deployment-torch/code/batch_driver.py.

    7. I avsnittet "Välj miljö" väljer du den miljö som du skapade tidigare torch-batch-env.

    8. Välj Nästa för att gå till sidan "Beräkning".

    9. Välj det beräkningskluster som du skapade i ett tidigare steg.

      Varning

      Azure Kubernetes-kluster stöds i batchdistributioner, men endast när de skapas med Hjälp av Azure Machine Learning CLI eller Python SDK.

    10. För Antal instanser anger du det antal beräkningsinstanser som du vill använda för distributionen. I det här fallet använder du 2.

    11. Välj Nästa.

  11. Skapa distributionen:

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

    az ml batch-deployment create --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default

    Dricks

    Parametern --set-default anger den nyligen skapade distributionen som standarddistribution av slutpunkten. Det är ett praktiskt sätt att skapa en ny standarddistribution av slutpunkten, särskilt när du skapar den första distributionen. Som bästa praxis för produktionsscenarier kanske du vill skapa en ny distribution utan att ange den som standard. Kontrollera att distributionen fungerar som förväntat och uppdatera sedan standarddistributionen senare. Mer information om hur du implementerar den här processen finns i avsnittet Distribuera en ny modell .

  12. Kontrollera information om batchslutpunkt och distribution.

    Använd show för att kontrollera slutpunkts- och distributionsinformationen. Kontrollera en batchdistribution genom att köra följande kod:

    DEPLOYMENT_NAME="mnist-torch-dpl"
az ml batch-deployment show --name $DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME

  13. Välj fliken Batch-slutpunkter .

    1. Välj den batchslutpunkt som du vill visa.

    2. Sidan Information för slutpunkten visar information om slutpunkten tillsammans med alla distributioner som är tillgängliga i slutpunkten.

      Skärmbild av kontrollera batchslutpunkter och distributionsinformation.

Köra batchslutpunkter och få åtkomst till resultat

Förstå dataflödet

Innan du kör batchslutpunkten ska du förstå hur data flödar genom systemet:

Indata: Data som ska bearbetas (poäng). Detta omfattar:

  • Filer som lagras i Azure Storage (bloblagring, datasjö)
  • Mappar med flera filer
  • Registrerade datauppsättningar i Azure Machine Learning

Bearbetning: Den distribuerade modellen bearbetar indata i batchar (mini-batchar) och genererar förutsägelser.

Utdata: Resultat från modellen som lagras som filer i Azure Storage. Som standard sparas utdata till arbetsytans standardbloblagring, men du kan ange en annan plats.

Anropa en batchslutpunkt

Om du anropar en batchslutpunkt utlöses ett batchbedömningsjobb. Jobbet name returneras i anropssvaret och övervakar batchpoängberäkningsprocessen. Ange sökvägen för indata så att slutpunkterna kan hitta de data som ska poängsättas. I följande exempel visas hur du startar ett nytt jobb över exempeldata för MNIST-datauppsättningen som lagras i ett Azure Storage-konto.

Du kan köra och anropa en batchslutpunkt med hjälp av Azure CLI, Azure Machine Learning SDK eller REST-slutpunkter. Mer information om de här alternativen finns i Skapa jobb och indata för batchslutpunkter.

Kommentar

Hur fungerar parallellisering?

Batchdistributioner distribuerar arbete på filnivå. Till exempel genererar en mapp med 100 filer och minibatch med 10 filer 10 batchar med 10 filer vardera. Detta sker oavsett filstorlek. Om filerna är för stora för bearbetning i mini-batchar delar du upp dem i mindre filer för att öka parallelliteten eller minska antalet filer per mini-batch. Batchdistributioner tar för närvarande inte hänsyn till skevhet i filstorleksfördelningen.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Batch-slutpunkter stöder läsning av filer eller mappar som finns på olika platser. Mer information om vilka typer som stöds och hur du anger dem finns i Komma åt data från batchslutpunktsjobb.

Övervaka körningsframsteg för batchjobb

Batchbedömningsjobb tar tid att bearbeta alla indata.

Följande kod kontrollerar jobbstatusen och matar ut en länk till Azure Machine Learning-studio för ytterligare information.

az ml job show -n $JOB_NAME --web

Kontrollera resultat för batchbedömning

Jobbutdata lagras i molnlagring, antingen i arbetsytans standardbloblagring eller i den lagring du angav. Information om hur du ändrar standardvärdena finns i Konfigurera utdataplatsen. Med följande steg kan du visa bedömningsresultaten i Azure Storage Explorer när jobbet har slutförts:

  1. Kör följande kod för att öppna batchbedömningsjobbet i Azure Machine Learning-studio. Jobbstudiolänken ingår också i svaret för invoke, som värdet för interactionEndpoints.Studio.endpoint.

    az ml job show -n $JOB_NAME --web

  2. Välj batchscoring steget i diagrammet för jobbet.

  3. Välj fliken Utdata + loggar och välj sedan Visa datautdata.

  4. Från Datautdata väljer du ikonen för att öppna Storage Explorer.

    Studio skärmbild som visar platsen för visning av datautdata.

    Bedömningsresultaten i Storage Explorer liknar följande exempelsida:

    Skärmbild av bedömningsutdata.

Konfigurera utdataplatsen

Som standardinställning lagras batchpoängresultat i arbetsytans standardbloblager i en mapp med namn efter arbetet (en systemgenererad GUID). Konfigurera utdataplatsen när batchslutpunkten anropas.

Använd output-path för att konfigurera valfri mapp i ett Azure Machine Learning-registrerat datalager. Syntaxen --output-path för är densamma som --input när du anger en mapp, dvs azureml://datastores/<datastore-name>/paths/<path-on-datastore>/. . Använd --set output_file_name=<your-file-name> för att konfigurera ett nytt namn på utdatafilen.

OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
OUTPUT_PATH="azureml://datastores/workspaceblobstore/paths/$ENDPOINT_NAME"

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Varning

Du måste använda en unik utdataplats. Om utdatafilen finns misslyckas batchbedömningsjobbet.

Viktigt!

Till skillnad från indata kan utdata endast lagras i Azure Machine Learning-datalager som körs på bloblagringskonton.

Skriva över distributionskonfigurationen för varje jobb

När du anropar en batchslutpunkt kan du skriva över vissa inställningar för att använda beräkningsresurser på bästa sätt och förbättra prestandan. Den här funktionen är användbar när du behöver olika inställningar för olika jobb utan att permanent ändra distributionen.

Vilka inställningar kan åsidosättas?

Du kan konfigurera följande inställningar per jobb:

Inställning När man ska använda Exempelscenario
Antal instanser När du har olika datavolymer Använd fler instanser för större datamängder (10 instanser för 1 miljon filer jämfört med 2 instanser för 100 000 filer).
Mini-batchstorlek När du behöver balansera dataflöde och minnesanvändning Använd mindre batchar (10–50 filer) för stora bilder och större batchar (100–500 filer) för små textfiler.
Maximalt antal återförsök När datakvaliteten varierar Högre återförsök (5–10) för brusdata. lägre återförsök (1–3) för rena data
Tidsgräns När bearbetningstiden varierar beroende på datatyp Längre tidsgräns (300-talet) för komplexa modeller. kortare timeout (30-talet) för enkla modeller
Tröskelvärde för fel När du behöver olika feltoleransnivåer Strikt tröskelvärde (-1) för kritiska jobb; överseende tröskelvärde (10%) för experimentella jobb

Så här åsidosätter du inställningar

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --mini-batch-size 20 --instance-count 5 --query name -o tsv)

Lägga till distributioner till en slutpunkt

När du har en batchslutpunkt med en distribution kan du fortsätta att förfina din modell och lägga till nya distributioner. Batch-slutpunkter fortsätter att hantera standarddistributionen medan du utvecklar och distribuerar nya modeller under samma slutpunkt. Distributioner påverkar inte varandra.

I det här exemplet lägger du till en andra distribution som använder en modell som skapats med Keras och TensorFlow för att lösa samma MNIST-problem.

Lägga till en andra distribution

  1. Skapa en miljö för batchdistributionen. Inkludera eventuella beroenden som koden behöver köra. Lägg till biblioteket azureml-core, eftersom det krävs för batchdistributioner. Följande miljödefinition innehåller de bibliotek som krävs för att köra en modell med TensorFlow.

    Miljödefinitionen ingår i själva distributionsdefinitionen som en anonym miljö.

    environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

  2. Kopiera innehållet i filen deployment-keras/environment/conda.yaml från GitHub-lagringsplatsen till portalen.

    1. Välj Nästa tills du kommer till sidan Granska.

    2. Välj Skapa och vänta tills miljön är klar att användas.

    Conda-filen som används ser ut så här:

    deployment-keras/environment/conda.yaml

    name: tensorflow-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - pandas
    - tensorflow
    - pillow
    - azureml-core
    - azureml-dataset-runtime[fuse]

  3. Skapa ett bedömningsskript för modellen:

    deployment-keras/code/batch_driver.py

    import os
import numpy as np
import pandas as pd
import tensorflow as tf
from typing import List
from os.path import basename
from PIL import Image
from tensorflow.keras.models import load_model


def init():
    global model

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")

    # load the model
    model = load_model(model_path)


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    for image_path in mini_batch:
        data = Image.open(image_path)
        data = np.array(data)
        data_batch = tf.expand_dims(data, axis=0)

        # perform inference
        pred = model.predict(data_batch)

        # Compute probabilities, classes and labels
        pred_prob = tf.math.reduce_max(tf.math.softmax(pred, axis=-1)).numpy()
        pred_class = tf.math.argmax(pred, axis=-1).numpy()

        results.append(
            {
                "file": basename(image_path),
                "class": pred_class[0],
                "probability": pred_prob,
            }
        )

    return pd.DataFrame(results)

  4. Skapa en distributionsdefinition

    deployment-keras/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
name: mnist-keras-dpl
description: A deployment using Keras with TensorFlow to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model: 
  name: mnist-classifier-keras
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv

  5. Välj Nästa för att fortsätta till sidan "Kod + miljö".

    1. För Välj ett bedömningsskript för slutsatsdragning bläddrar du till att välja bedömningsskriptfilen deployment-keras/code/batch_driver.py.

    2. För Välj miljö väljer du den miljö som du skapade i ett tidigare steg.

    3. Välj Nästa.

    4. På sidan Beräkning väljer du det beräkningskluster som du skapade i ett tidigare steg.

    5. För Antal instanser anger du det antal beräkningsinstanser som du vill använda för distributionen. I det här fallet använder du 2.

    6. Välj Nästa.

  6. Skapa distributionen:

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

    az ml batch-deployment create --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME

    Dricks

    Parametern --set-default saknas i det här fallet. Som bästa praxis för produktionsscenarier skapar du en ny distribution utan att ange den som standard. Kontrollera det sedan och uppdatera standarddistributionen senare.

Testa en batchdistribution som inte är standard

Om du vill testa den nya icke-standarddistributionen måste du känna till namnet på den distribution som du vill köra.

DEPLOYMENT_NAME="mnist-keras-dpl"
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --deployment-name $DEPLOYMENT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Observera --deployment-name används för att ange vilken distribution som ska köras. Med den här parametern kan du utföra invoke en icke-standarddistribution utan att uppdatera standarddistributionen av batchslutpunkten.

Uppdatera standarddistributionen av batchar

Även om du kan anropa en specifik distribution i en slutpunkt vill du vanligtvis anropa själva slutpunkten och låta slutpunkten bestämma vilken distribution som ska användas – standarddistributionen. Du kan ändra standarddistributionen (och därmed ändra modellen som betjänar distributionen) utan att ändra ditt kontrakt med användaren som anropar slutpunkten. Använd följande kod för att uppdatera standarddistributionen:

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

Ta bort batchslutpunkten och distributionen

Om du inte behöver den gamla batchdistributionen tar du bort den genom att köra följande kod. Flaggan --yes bekräftar borttagningen.

az ml batch-deployment delete --name mnist-torch-dpl --endpoint-name $ENDPOINT_NAME --yes

Kör följande kod för att ta bort batchslutpunkten och dess underliggande distributioner. Batchbedömningsjobb tas inte bort.

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

Relaterat innehåll