Dela via

Avbildningsbearbetning med distributioner av batchmodeller

  • Artikel

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

Batch-modelldistributioner kan användas för bearbetning av tabelldata, men även andra filtyper som bilder. Dessa distributioner stöds i både MLflow och anpassade modeller. I den här självstudien får du lära dig hur du distribuerar en modell som klassificerar bilder enligt ImageNet-taxonomi.

Om det här exemplet

Modellen som vi ska arbeta med skapades med TensorFlow tillsammans med RestNet-arkitekturen (Identitetsmappningar i djupa residualnätverk). Ett exempel på den här modellen kan laddas ned härifrån. Modellen har följande begränsningar som är viktiga att tänka på för distributionen:

  • Den fungerar med bilder av storlek 244x244 (tensorer av (224, 224, 3)).
  • Det kräver att indata skalas till intervallet [0,1].

Informationen i den här artikeln baseras på kodexempel som finns i lagringsplatsen azureml-examples . Om du vill köra kommandona lokalt utan att behöva kopiera/klistra in YAML och andra filer klonar du lagringsplatsen och ändrar sedan katalogerna till cli/endpoints/batch/deploy-models/imagenet-classifier om du använder Azure CLI eller sdk/python/endpoints/batch/deploy-models/imagenet-classifier om du använder vårt SDK för Python.

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

Följ med i Jupyter Notebooks

Du kan följa det här exemplet i en Jupyter Notebook. På den klonade lagringsplatsen öppnar du notebook-filen: imagenet-classifier-batch.ipynb.

Förutsättningar

Innan du följer stegen i den här artikeln kontrollerar du att du har följande 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 Machine Learning.

  • En Azure Machine Learning-arbetsyta. Om du inte har någon använder du stegen i artikeln Hantera Azure Machine Learning-arbetsytor för att skapa en.

  • Kontrollera att du har följande behörigheter på arbetsytan:

    • Skapa eller hantera batchslutpunkter och distributioner: Använd en ägare, deltagare eller anpassad roll som tillåter Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

    • Skapa ARM-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.

  • Du måste installera följande programvara för att arbeta med Azure Machine Learning:

    Azure CLI och mltillägget för Azure Machine Learning.

    az extension add -n ml

    Kommentar

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

Anslut till din arbetsyta

Arbetsytan är resursen på den översta nivån i Azure Machine Learning, och är en central plats där du kan arbeta med alla artefakter du skapar när du använder Azure Machine Learning. I det här avsnittet ansluter vi till arbetsytan där du ska utföra distributionsuppgifter.

Skicka in värdena för ditt prenumerations-ID, arbetsyta, plats och resursgrupp i följande kod:

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

Bildklassificering med batchdistributioner

I det här exemplet ska vi lära oss hur du distribuerar en djupinlärningsmodell som kan klassificera en viss avbildning enligt taxonomi för ImageNet.

Skapa slutpunkten

Först ska vi skapa den slutpunkt som ska vara värd för modellen:

Bestäm namnet på slutpunkten:

ENDPOINT_NAME="imagenet-classifier-batch"

Följande YAML-fil definierar en batchslutpunkt:

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: imagenet-classifier-batch
description: A batch endpoint for performing image classification using a TFHub model ImageNet model.
auth_mode: aad_token

Kör följande kod för att skapa slutpunkten.

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

Registrera modellen

Modelldistributioner kan bara distribuera registrerade modeller så vi behöver registrera dem. Du kan hoppa över det här steget om den modell som du försöker distribuera redan är registrerad.

  1. Laddar ned en kopia av modellen:

    wget https://azuremlexampledata.blob.core.windows.net/data/imagenet/model.zip
unzip model.zip -d .

  2. Registrera modellen:

    MODEL_NAME='imagenet-classifier'
az ml model create --name $MODEL_NAME --path "model"

Skapa ett bedömningsskript

Vi måste skapa ett bedömningsskript som kan läsa avbildningarna som tillhandahålls av batchdistributionen och returnera poängen för modellen. Följande skript:

  • Anger en init funktion som läser in modellen med hjälp av keras modulen i tensorflow.
  • Anger en run funktion som körs för varje mini-batch som batchdistributionen tillhandahåller.
  • Funktionen run läser en bild av filen i taget
  • Metoden run ändrar storlek på bilderna till de förväntade storlekarna för modellen.
  • Metoden run skalar om bilderna till intervalldomänen [0,1] , vilket är vad modellen förväntar sig.
  • Den returnerar klasserna och sannolikheterna som är associerade med förutsägelserna.

code/score-by-file/batch_driver.py

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


def init():
    global model
    global input_width
    global input_height

    # 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)
    input_width = 244
    input_height = 244


def run(mini_batch):
    results = []

    for image in mini_batch:
        data = Image.open(image).resize(
            (input_width, input_height)
        )  # Read and resize the image
        data = np.array(data) / 255.0  # Normalize
        data_batch = tf.expand_dims(
            data, axis=0
        )  # create a batch of size (1, 244, 244, 3)

        # 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([basename(image), pred_class[0], pred_prob])

    return pd.DataFrame(results)

Dricks

Även om avbildningar tillhandahålls i minibatch av distributionen bearbetar det här bedömningsskriptet en bild i taget. Det här är ett vanligt mönster eftersom försök att läsa in hela batchen och skicka den till modellen på en gång kan leda till hög minnesbelastning på batchexekutorn (OOM-exeptions). Det finns dock vissa fall där det möjliggör högt dataflöde i bedömningsuppgiften. Detta gäller för instanser av batchdistributioner över en GPU-maskinvara där vi vill uppnå hög GPU-användning. Se Distributioner med högt dataflöde för ett exempel på ett bedömningsskript som utnyttjar det.

Kommentar

Om du försöker distribuera en generativ modell (en som genererar filer) läser du hur du skapar ett bedömningsskript enligt beskrivningen i Distribution av modeller som producerar flera filer.

Skapa distributionen

Ett bedömningsskript skapas, det är dags att skapa en batchdistribution för det. Följ följande steg för att skapa det:

  1. Se till att du har skapat ett beräkningskluster där vi kan skapa distributionen. I det här exemplet ska vi använda ett beräkningskluster med namnet gpu-cluster. Även om det inte krävs använder vi GPU:er för att påskynda bearbetningen.

  2. Vi måste ange över vilken miljö vi ska köra distributionen. I vårt fall körs vår modell på TensorFlow. Azure Machine Learning har redan en miljö med nödvändig programvara installerad, så vi kan återanvända den här miljön igen. Vi ska bara lägga till ett par beroenden i en conda.yml fil.

    Miljödefinitionen inkluderas i distributionsfilen.

    compute: azureml:gpu-cluster
environment:
  name: tensorflow212-cuda11-gpu
  image: mcr.microsoft.com/azureml/curated/tensorflow-2.12-cuda11:latest

  3. Nu ska vi skapa distributionen.

    Om du vill skapa en ny distribution under den skapade slutpunkten skapar du en YAML konfiguration som följande. Du kan kontrollera YAML-schemat för den fullständiga batchslutpunkten för extra egenskaper.

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: imagenet-classifier-batch
name: imagenet-classifier-resnetv2
description: A ResNetV2 model architecture for performing ImageNet classification in batch
type: model
model: azureml:imagenet-classifier@latest
compute: azureml:gpu-cluster
environment:
  name: tensorflow212-cuda11-gpu
  image: mcr.microsoft.com/azureml/curated/tensorflow-2.12-cuda11:latest
  conda_file: environment/conda.yaml
code_configuration:
  code: code/score-by-file
  scoring_script: batch_driver.py
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 1
  mini_batch_size: 5
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 300
  error_threshold: -1
  logging_level: info

    Skapa sedan distributionen med följande kommando:

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

  4. Ä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. En sådan distribution heter "standard"-distributionen. Detta ger dig möjlighet att ändra standarddistributionen – och därmed ändra modellen som betjänar distributionen – utan att ändra kontraktet med användaren som anropar slutpunkten. Använd följande instruktion för att uppdatera standarddistributionen:

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

  5. Nu är vår batchslutpunkt redo att användas.

Testa distributionen

För att testa slutpunkten använder vi ett exempel på 1 000 bilder från den ursprungliga ImageNet-datauppsättningen. Batch-slutpunkter kan bara bearbeta data som finns i molnet och som är tillgängliga från Azure Machine Learning-arbetsytan. I det här exemplet ska vi ladda upp det till ett Azure Machine Learning-datalager. I synnerhet ska vi skapa en datatillgång som kan användas för att anropa slutpunkten för bedömning. Observera dock att batchslutpunkter accepterar data som kan placeras på flera typer av platser.

  1. Nu ska vi ladda ned associerade exempeldata:

    wget https://azuremlexampledata.blob.core.windows.net/data/imagenet/imagenet-1000.zip
unzip imagenet-1000.zip -d data

  2. Nu ska vi skapa datatillgången från data som precis har laddats ned

    Skapa en datatillgångsdefinition i YAML:

    imagenet-sample-unlabeled.yml

    $schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: imagenet-sample-unlabeled
description: A sample of 1000 images from the original ImageNet dataset. Download content from https://azuremlexampledata.blob.core.windows.net/data/imagenet-1000.zip.
type: uri_folder
path: data

    Skapa sedan datatillgången:

    az ml data create -f imagenet-sample-unlabeled.yml

  3. Nu när data har laddats upp och är redo att användas ska vi anropa slutpunkten:

    JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input azureml:imagenet-sample-unlabeled@latest --query name -o tsv)

    Kommentar

    Verktyget jq kanske inte installeras på varje installation. Du kan få instruktioner i den här länken.

    Dricks

    Observera att vi inte anger distributionsnamnet i anropsåtgärden. Det beror på att slutpunkten automatiskt dirigerar jobbet till standarddistributionen. Eftersom vår slutpunkt bara har en distribution är den standard. Du kan rikta en specifik distribution genom att ange argumentet/parametern deployment_name.

  4. Ett batchjobb startas så snart kommandot returnerar. Du kan övervaka statusen för jobbet tills det har slutförts:

    az ml job show -n $JOB_NAME --web

  5. När distributionen är klar kan vi ladda ned förutsägelserna:

    Om du vill ladda ned förutsägelserna använder du följande kommando:

    az ml job download --name $JOB_NAME --output-name score --download-path ./

  6. Utdataförutsägelserna ser ut så här. Observera att förutsägelserna har kombinerats med etiketterna för att underlätta för läsaren. Mer information om hur du uppnår detta finns i den associerade notebook-filen.

    import pandas as pd
score = pd.read_csv("named-outputs/score/predictions.csv", header=None,  names=['file', 'class', 'probabilities'], sep=' ')
score['label'] = score['class'].apply(lambda pred: imagenet_labels[pred])
score
    fil klass Sannolikheter label
    n02088094_Afghan_hound. JPEG 161 0.994745 Afghansk hund
    n02088238_basset 162 0.999397 Basset
    n02088364_beagle. JPEG 165 0.366914 bluetick
    n02088466_bloodhound. JPEG 164 0.926464 Bloodhound
    ... ... ... ...

Distributioner med högt dataflöde

Som tidigare nämnts bearbetar distributionen vi nyss en avbildning i taget, även när batchdistributionen tillhandahåller en batch av dem. I de flesta fall är detta den bästa metoden eftersom det förenklar hur modellerna körs och undviker eventuella problem med slut på minne. Men i vissa andra kanske vi vill mätta så mycket som möjligt användningen av den underliggande maskinvaran. Det här är till exempel fallet GPU:er.

I dessa fall kanske vi vill utföra slutsatsdragning på hela databatchen. Det innebär att läsa in hela uppsättningen bilder till minnet och skicka dem direkt till modellen. I följande exempel används TensorFlow för att läsa batchen med bilder och poängsätta dem alla samtidigt. Den använder TensorFlow också ops för att göra alla data förbearbetning så att hela pipelinen sker på samma enhet som används (CPU/GPU).

Varning

Vissa modeller har en icke-linjär relation med storleken på indata när det gäller minnesförbrukning. Batcha igen (som i det här exemplet) eller minska storleken på batcharna som skapas av batchdistributionen för att undvika undantag som inte är minnesfria.

  1. Skapa bedömningsskriptet:

    code/score-by-batch/batch_driver.py

    import os
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.models import load_model


def init():
    global model
    global input_width
    global input_height

    # 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)
    input_width = 244
    input_height = 244


def decode_img(file_path):
    file = tf.io.read_file(file_path)
    img = tf.io.decode_jpeg(file, channels=3)
    img = tf.image.resize(img, [input_width, input_height])
    return img / 255.0


def run(mini_batch):
    images_ds = tf.data.Dataset.from_tensor_slices(mini_batch)
    images_ds = images_ds.map(decode_img).batch(64)

    # perform inference
    pred = model.predict(images_ds)

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

    return pd.DataFrame(
        [mini_batch, pred_prob, pred_class], columns=["file", "probability", "class"]
    )

    Dricks

    • Observera att det här skriptet konstruerar en tensor-datauppsättning från mini-batchen som skickas av batchdistributionen. Den här datamängden är förbearbetad för att hämta förväntade tensorer för modellen med hjälp av map åtgärden med funktionen decode_img.
    • Datauppsättningen batchas igen (16) skickar data till modellen. Använd den här parametern för att styra hur mycket information du kan läsa in i minnet och skicka till modellen samtidigt. Om du kör på en GPU måste du noggrant justera den här parametern för att uppnå den maximala användningen av GPU:n precis innan du får ett OOM-undantag.
    • När förutsägelserna har beräknats konverteras tensorerna till numpy.ndarray.

  2. Nu ska vi skapa distributionen.

    Om du vill skapa en ny distribution under den skapade slutpunkten skapar du en YAML konfiguration som följande. Du kan kontrollera YAML-schemat för den fullständiga batchslutpunkten för extra egenskaper.

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: imagenet-classifier-batch
name: imagenet-classifier-resnetv2
description: A ResNetV2 model architecture for performing ImageNet classification in batch
type: model
model: azureml:imagenet-classifier@latest
compute: azureml:gpu-cluster
environment:
  name: tensorflow212-cuda11-gpu
  image: mcr.microsoft.com/azureml/curated/tensorflow-2.12-cuda11:latest
  conda_file: environment/conda.yaml
code_configuration:
  code: code/score-by-batch
  scoring_script: batch_driver.py
resources:
  instance_count: 2
tags:
  device_acceleration: CUDA
  device_batching: 16
settings:
  max_concurrency_per_instance: 1
  mini_batch_size: 5
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 300
  error_threshold: -1
  logging_level: info

    Skapa sedan distributionen med följande kommando:

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

  3. Du kan använda den här nya distributionen med de exempeldata som visades tidigare. Kom ihåg att om du vill anropa den här distributionen bör du antingen ange namnet på distributionen i anropsmetoden eller ange den som standard.

Överväganden för MLflow-modeller som bearbetar bilder

MLflow-modeller i Batch-slutpunkter stöder läsning av bilder som indata. Eftersom MLflow-distributioner inte kräver ett bedömningsskript bör du tänka på följande när du använder dem:

  • Bildfiler som stöds omfattar: .png, .jpg, .jpeg, .bmp.tiffoch .gif.
  • MLflow-modeller bör förvänta sig att få en np.ndarray som indata som matchar dimensionerna för indatabilden. För att stödja flera bildstorlekar för varje batch anropar batch-kören MLflow-modellen en gång per bildfil.
  • MLflow-modeller rekommenderas starkt att inkludera en signatur, och om de gör det måste de vara av typen TensorSpec. Indata omformas för att matcha tensors form om den är tillgänglig. Om ingen signatur är tillgänglig härleds tensorer av typen np.uint8 .
  • För modeller som innehåller en signatur och förväntas hantera varierande storlek på bilder ska du sedan inkludera en signatur som kan garantera den. I följande signaturexempel tillåts till exempel batchar med 3 kanalbaserade bilder.
import numpy as np
import mlflow
from mlflow.models.signature import ModelSignature
from mlflow.types.schema import Schema, TensorSpec

input_schema = Schema([
  TensorSpec(np.dtype(np.uint8), (-1, -1, -1, 3)),
])
signature = ModelSignature(inputs=input_schema)

(...)

mlflow.<flavor>.log_model(..., signature=signature)

Du hittar ett fungerande exempel i Jupyter Notebook imagenet-classifier-mlflow.ipynb. Mer information om hur du använder MLflow-modeller i batchdistributioner finns i Använda MLflow-modeller i batchdistributioner.

Nästa steg