Distribuera modeller för bedömning i batchslutpunkter

  • Artikel

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

Batch-slutpunkter är ett bekvämt sätt att distribuera modeller som kör slutsatsdragning över stora mängder data. De här slutpunkterna förenklar processen med att vara värd för dina modeller för batchbedömning, så att fokus ligger på maskininlärning snarare än infrastrukturen.

Använd batchslutpunkter för modelldistribution när:

  • Du har dyra modeller som kräver längre tid för att köra slutsatsdragning.
  • Du måste utföra slutsatsdragning för stora mängder data som distribueras i flera filer.
  • Du har inte krav på låg svarstid.
  • Du kan dra nytta av parallellisering.

I den här artikeln använder du en batchslutpunkt för att distribuera en maskininlärningsmodell som löser det klassiska MNIST-igenkänningsproblemet (Modified National Institute of Standards and Technology). Din distribuerade modell utför sedan batchinferens över stora mängder data – i det här fallet bildfiler. Du börjar med att skapa en batchdistribution av en modell som skapades med hjälp av Torch. Den här distributionen blir standard i slutpunkten. Senare skapar du en andra distribution av ett läge som skapades med TensorFlow (Keras), testar den andra distributionen och anger den sedan som slutpunktens standarddistribution.

Om du vill följa med i de kodexempel och filer som behövs för att köra kommandona i den här artikeln lokalt kan du läsa avsnittet Klona exempellagringsplatsen. Kodexemplen och filerna finns i lagringsplatsen azureml-examples .

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

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 skicka in 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. Du kan 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 kan anropa för att utlösa ett batchbedömningsjobb. Ett batchbedömningsjobb är ett jobb som poängsätter flera indata. En batchdistribution är en uppsättning beräkningsresurser som är värdar för modellen som utför den faktiska batchbedömningen (eller batchinferensen). 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 den faktiska batchbedömningen. 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 så att du enkelt kan referera till den senare.

    ENDPOINT_NAME="mnist-batch"

  2. Konfigurera batchslutpunkten

    Följande YAML-fil definierar en batchslutpunkt. Du kan använda 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-schema (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 följande kod 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ördefinierade 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, förutsatt att 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 observera 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 ska köras. 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 tas med 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

    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.

  4. 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 [Valfritt] Det maximala antalet parallella scoring_script körningar per instans.
    settings.mini_batch_size [Valfritt] Antalet filer som kan bearbetas scoring_script i ett run() anrop.
    settings.output_action [Valfritt] 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 [Valfritt] Namnet på batchbedömningsutdatafilen för append_rowoutput_action.
    settings.retry_settings.max_retries [Valfritt] Antalet maximala försök för en misslyckad scoring_scriptrun().
    settings.retry_settings.timeout [Valfritt] Tidsgränsen i sekunder för en scoring_scriptrun() för bedömning av en minibatch.
    settings.error_threshold [Valfritt] 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 [Valfritt] Log verbosity. Värden i ökande verbositet är: WARNING, INFO och DEBUG.
    settings.environment_variables [Valfritt] Ordlista över miljövariabelns namn/värde-par som ska anges för varje batchbedömningsjobb.

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

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

Köra batchslutpunkter och få åtkomst till resultat

Om du anropar en batchslutpunkt utlöses ett batchbedömningsjobb. Jobbet name returneras från anropssvaret och kan användas för att spåra batchbedömningsförloppet. När du kör modeller för bedömning i batchslutpunkter måste du ange sökvägen till indata så att slutpunkterna kan hitta de data som du vill poängsätta. 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å, vilket innebär att en mapp som innehåller 100 filer med mini-batchar med 10 filer genererar 10 batchar med 10 filer vardera. Observera att detta sker oavsett storleken på de aktuella filerna. Om dina filer är för stora för att bearbetas i stora mini-batchar föreslår vi att du antingen delar upp filerna i mindre filer för att uppnå en högre nivå av parallellitet eller så minskar du antalet filer per mini-batch. För närvarande kan batchdistributioner inte ta hänsyn till skevhet i en fils storleksfördelning.

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 vanligtvis lite tid att bearbeta hela uppsättningen 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 standard lagras batchbedömningsresultatet i arbetsytans standardbloblager i en mapp med namnet efter jobbnamn (ett systemgenererat GUID). Du kan konfigurera var du vill lagra bedömningsutdata när du anropar batchslutpunkten.

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 vissa inställningar skrivas över för att använda beräkningsresurserna på bästa sätt och förbättra prestandan. Följande inställningar kan konfigureras per jobb:

  • Antal instanser: Använd den här inställningen för att skriva över antalet instanser som ska begäras från beräkningsklustret. För större mängder dataindata kanske du vill använda fler instanser för att påskynda batchbedömningen från slutpunkt till slutpunkt.
  • Mini-batchstorlek: Använd den här inställningen för att skriva över antalet filer som ska inkluderas i varje mini-batch. Antalet minibatch bestäms av det totala antalet indatafiler och minibatchstorleken. En mindre mini-batch-storlek genererar fler minibatch. Minibatch kan köras parallellt, men det kan finnas extra schemaläggning och anrop.
  • Andra inställningar, till exempel maximala återförsök, tidsgräns och tröskelvärde för fel kan skrivas över. De här inställningarna kan påverka batchbedömningstiden från slutpunkt till slutpunkt för olika arbetsbelastningar.
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ö där batchdistributionen ska köras. Inkludera alla beroenden som koden kräver för att köras i miljön. Du måste också lägga till biblioteket azureml-coreeftersom det krävs för att batchdistributioner ska fungera. Följande miljödefinition har 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

    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]

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

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

  4. 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 använder den gamla batchdistributionen tar du bort den genom att köra följande kod. --yes används för att bekräfta 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 alla dess underliggande distributioner. Batchbedömningsjobb tas inte bort.

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

Relaterat innehåll