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)

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

Förutsättningar

  • En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

  • En Azure Machine Learning-arbetsyta. Information om hur du skapar en arbetsyta finns i Hantera Azure Machine Learning-arbetsytor.

  • Följande behörigheter på Azure Machine Learning-arbetsytan:

    • För att skapa eller hantera batchslutpunkter och distributioner: Använd en ägare, deltagare eller anpassad roll som har tilldelats behörigheterna Microsoft.MachineLearningServices/workspaces/batchEndpoints/* .
    • För att skapa Azure Resource Manager-distributioner i arbetsytans resursgrupp: Använd en ägare, deltagare eller anpassad roll som har tilldelats behörigheten Microsoft.Resources/deployments/write i resursgruppen där arbetsytan distribueras.

  • Azure Machine Learning CLI eller Azure Machine Learning SDK för Python:

    Kör följande kommando för att installera Azure CLI och ml tillägget för Azure Machine Learning:

    az extension add -n ml

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

Anslut till din arbetsyta

Arbetsytan är resursen på den översta nivån för Azure Machine Learning. Det är en central plats där du kan arbeta med alla artefakter som du skapar när du använder Azure Machine Learning. I det här avsnittet ansluter du till arbetsytan där du utför dina distributionsuppgifter.

I följande kommando anger du ditt prenumerations-ID, arbetsytans namn, resursgruppsnamn och plats:

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

Om det här exemplet

Den här artikeln använder en modell som har skapats med TensorFlow tillsammans med RestNet-arkitekturen. Mer information finns i Identitetsmappningar i djupa kvarvarande nätverk. Du kan ladda ned ett exempel på den här modellen. Modellen har följande begränsningar:

  • 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. Ändra kataloger 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 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.

Bildklassificering med batchdistributioner

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

Skapa slutpunkten

Skapa den slutpunkt som är värd för modellen:

  1. Ange namnet på slutpunkten.

    ENDPOINT_NAME="imagenet-classifier-batch"

  2. Skapa följande YAML-fil för att definiera batchslutpunkten med namnet 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. Du måste registrera modellen. Du kan hoppa över det här steget om den modell som du försöker distribuera redan är registrerad.

  1. Ladda 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

Skapa ett bedömningsskript som kan läsa avbildningarna som tillhandahålls av batchdistributionen och returnera poängen för modellen.

  • Metoden init läser in modellen med hjälp av modulen keras i tensorflow.
  • Metoden run körs för varje mini-batch som batchdistributionen tillhandahåller.
  • Metoden 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.
  • Skriptet returnerar klasserna och sannolikheterna som är associerade med förutsägelserna.

Den här koden är filen 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 samtidigt kan leda till hög minnesbelastning på batchexekutorn (OOM-undantag).

Det finns vissa fall där det möjliggör högt dataflöde i bedömningsuppgiften. Detta gäller för batchdistributioner via GPU-maskinvara där du vill uppnå hög GPU-användning. Ett bedömningsskript som utnyttjar den här metoden finns i Distributioner med högt dataflöde.

Kommentar

Om du vill distribuera en generativ modell, som genererar filer, lär du dig hur du skapar ett bedömningsskript: Anpassa utdata i batchdistributioner.

Skapa distributionen

När du har skapat bedömningsskriptet skapar du en batchdistribution för det. Följ dessa steg:

  1. Se till att du har skapat ett beräkningskluster där du kan skapa distributionen. I det här exemplet använder du ett beräkningskluster med namnet gpu-cluster. Även om det inte krävs, påskyndas bearbetningen med hjälp av GPU:er.

  2. Ange vilken miljö som distributionen ska köras i. I det här exemplet körs modellen på TensorFlow. Azure Machine Learning har redan en miljö med nödvändig programvara installerad, så du kan återanvända den här miljön. Du måste lägga till ett par beroenden i en conda.yml fil.

    Miljödefinitionen ingår i distributionsfilen.

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

  3. Skapa distributionen.

    Om du vill skapa en ny distribution under den skapade slutpunkten skapar du en YAML konfiguration som i följande exempel. Andra egenskaper finns i YAML-schemat för den fullständiga batchslutpunkten.

    $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 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 kallas för standarddistribution .

    Med den här metoden kan du ändra standarddistributionen och ändra den modell som betjänar distributionen utan att ändra kontraktet 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

Batchslutpunkten är redo att användas.

Testa distributionen

För att testa slutpunkten använder du 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. Ladda upp den till ett Azure Machine Learning-datalager. Skapa en datatillgång som kan användas för att anropa slutpunkten för bedömning.

Kommentar

Batchslutpunkter accepterar data som kan placeras på flera typer av platser.

  1. Ladda ned tillhörande exempeldata.

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

    Kommentar

    Om du inte har wget installerat lokalt installerar du det eller använder en webbläsare för att hämta .zip-filen.

  2. Skapa datatillgången från data som laddats ned.

    1. Skapa en datatillgångsdefinition i en YAML fil med namnet 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

    2. Skapa datatillgången.

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

  3. När data laddas upp och är redo att användas anropar du slutpunkten.

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

    Kommentar

    Om verktyget jq inte är installerat läser du Ladda ned jq.

Dricks

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

  1. Ett batchjobb startar så snart kommandot returnerar. Du kan övervaka status för jobbet tills det har slutförts.

    az ml job show -n $JOB_NAME --web

  2. När distributionen är klar laddar du 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 ./

  3. Förutsägelserna ser ut som följande utdata. Förutsägelserna kombineras med etiketterna för att underlätta för läsaren. Mer information om hur du uppnår den här effekten 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 blodhund
    ... ... ... ...

Distributioner med högt dataflöde

Som tidigare nämnts bearbetar distributionen en avbildning i taget, även när batchdistributionen tillhandahåller en batch av dem. I de flesta fall är den här metoden bäst. Det förenklar hur modellerna körs och undviker eventuella minnesproblem. Men i vissa andra fall kanske du vill mätta den underliggande maskinvaran så mycket som möjligt. Den här situationen är till exempel fallet GPU:er.

I dessa fall kanske du vill dra slutsatser om hela databatchen. Den metoden 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 även ops för att utföra förbearbetning av data. 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. För att undvika undantag utan minne kan du batcha igen (som i det här exemplet) eller minska storleken på de batchar som skapas av batchdistributionen.

  1. Skapa bedömningsskriptkoden /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"]
    )
    • 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) för att skicka 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 den körs på en GPU måste du noggrant justera den här parametern för att uppnå maximal användning 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. Skapa distributionen.

    1. Om du vill skapa en ny distribution under den skapade slutpunkten skapar du en YAML konfiguration som i följande exempel. Andra egenskaper finns i YAML-schemat för den fullständiga batchslutpunkten.
    $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
    1. Skapa 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 anger du antingen namnet på distributionen i anropsmetoden eller anger 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 är: .png, .jpg, .jpeg, .tiff, .bmp och .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 på varje batch anropar batchexekutorn MLflow-modellen en gång per bildfil.
  • MLflow-modeller rekommenderas starkt att inkludera en signatur. Om de gör det måste det 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 inkluderar du en signatur som kan garantera den. Till exempel tillåter följande signaturexempel 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