Teilen über

Bildverarbeitung mit Batchmodellimplementierungen

  • Artikel

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python SDK azure-ai-ml v2 (aktuell)

Sie können Batchmodellimplementierungen für die Verarbeitung von Tabellendaten verwenden, aber auch für die Verarbeitung aller anderen Dateitypen wie Bilder. Diese Bereitstellungen werden sowohl in MLflow- als auch in benutzerdefinierten Modellen unterstützt. In diesem Artikel erfahren Sie, wie Sie ein Modell implementieren, das Bilder gemäß der ImageNet-Taxonomie klassifiziert.

Voraussetzungen

  • Ein Azure-Abonnement. Wenn Sie nicht über ein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen. Probieren Sie die kostenlose oder kostenpflichtige Version von Azure Machine Learning aus.

  • Ein Azure Machine Learning-Arbeitsbereich. Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Verwalten von Azure Machine Learning-Arbeitsbereichen.

  • Stellen Sie sicher, dass Sie über die folgenden Berechtigungen im Machine Learning-Arbeitsbereich verfügen:

    • Erstellen oder Verwalten von Batchendpunkten und Batchbereitstellungen: Verwenden Sie die Rolle für Besitzer oder Mitwirkende oder eine benutzerdefinierte Rolle, die Microsoft.MachineLearningServices/workspaces/batchEndpoints/* zulässt.
    • Erstellen von Azure Resource Manager-Bereitstellungen in der Arbeitsbereichsressourcengruppe: Verwenden Sie „Besitzer“-, „Mitwirkender“- oder eine benutzerdefinierte Rolle, die Microsoft.Resources/deployments/write in der Ressourcengruppe zulässt, in der der Arbeitsbereich bereitgestellt wird.

  • Installieren Sie die folgende Software, um mit Machine Learning zu arbeiten:

    Führen Sie den folgenden Befehl aus, um die Azure CLI und die ml-Erweiterung für Azure Machine Learning zu installieren:

    az extension add -n ml

    Bereitstellungen der Pipelinekomponenten für Batchendpunkte werden in Version 2.7 der ml-Erweiterung für die Azure CLI eingeführt. Verwenden Sie den az extension update --name ml-Befehl, um die aktuelle Version abzurufen.

Herstellen einer Verbindung mit Ihrem Arbeitsbereich

Der Arbeitsbereich ist die wichtigste Ressource für maschinelles Lernen. Es bietet einen zentralen Ort für die Arbeit mit allen Artefakten, die Sie bei der Verwendung von Machine Learning erstellen. In diesem Abschnitt stellen Sie eine Verbindung mit dem Arbeitsbereich her, in dem Sie Ihre Bereitstellungsaufgaben durchführen.

Geben Sie im folgenden Befehl die Werte für Ihre Abonnement-ID, Ihren Arbeitsbereich, Ihren Standort und Ihre Ressourcengruppe ein:

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

Informationen zu diesem Beispiel

In diesem Artikel wird ein Modell verwendet, das mit TensorFlow und der RestNet-Architektur erstellt wurde. Weitere Informationen finden Sie unter Identity Mappings in Deep Residual Networks. Sie können ein Beispiel für dieses Modell herunterladen. Für das Modell gelten folgende Einschränkungen:

  • Es funktioniert mit Bildern der Größe 244x244 (Tensoren von (224, 224, 3)).
  • Es erfordert, dass Eingaben auf den Bereich [0,1] skaliert werden.

Die Informationen in diesem Artikel basieren auf Codebeispielen, die im Repository azureml-examples enthalten sind. Klonen Sie das Repository, um die Befehle lokal auszuführen, ohne YAML- und andere Dateien kopieren/einfügen zu müssen. Ändern Sie Verzeichnisse in cli/endpoints/batch/deploy-models/imagenet-classifier, wenn Sie die Azure CLI oder sdk/python/endpoints/batch/deploy-models/imagenet-classifier verwenden, wenn Sie das SDK für Python verwenden.

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

Folgen in Jupyter Notebooks

Sie können diesem Beispiel in einem Jupyter Notebook folgen. Öffnen Sie in dem geklonten Repository das folgende Notebook: imagenet-classifier-batch.ipynb.

Bildklassifizierung mit Batchbereitstellungen

In diesem Beispiel erfahren Sie, wie Sie ein Deep Learning-Modell implementieren, das ein bestimmtes Bild gemäß der Taxonomie von ImageNet klassifizieren kann.

Erstellen des Endpunkts

Erstellen Sie den Endpunkt, der das Modell hostet:

  1. Geben Sie den Namen des Endpunkts an.

    ENDPOINT_NAME="imagenet-classifier-batch"

  2. Erstellen Sie die folgende YAML-Datei, um den Batchendpunkt namens endpoint.yml zu definieren:

    $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

    Um den Endpunkt zu erstellen, führen Sie den folgenden Code aus:

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

Registrieren des Modells

Modellimplementierungen können nur registrierte Modelle bereitstellen. Sie müssen das Modell registrieren. Sie können diesen Schritt überspringen, wenn das Modell, das Sie bereitstellen möchten, bereits registriert ist.

  1. Laden Sie eine Kopie des Modells herunter.

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

  2. Registrieren des Modells.

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

Erstellen Sie ein Bewertungsskript.

Erstellen Sie ein Bewertungsskript, das die von der Batchbereitstellung bereitgestellten Bilder lesen und die Bewertungen des Modells zurückgeben kann.

  • Die init-Methode lädt das Modell mithilfe des keras-Moduls in tensorflow.
  • Die run-Methode wird für jeden Minibatch ausgeführt, den die Batchbereitstellung bereitstellt.
  • Die run-Methode liest jeweils ein Bild der Datei.
  • Die run-Methode ändert die Größe der Bilder in die erwarteten Größen für das Modell.
  • Die run-Methode führt für die Bilder eine Neuskalierung in die Bereichsdomäne [0,1] durch, die vom Modell erwartet wird.
  • Das Skript gibt die Klassen und die Wahrscheinlichkeiten im Zusammenhang mit den Vorhersagen zurück.

Dieser Code ist die Datei 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)

Tipp

Obwohl Bilder von der Bereitstellung in Minibatches bereitgestellt werden, verarbeitet dieses Bewertungsskript jeweils ein Bild. Dies ist ein gängiges Muster, weil es bei dem Versuch, den gesamten Batch zu laden und zugleich an das Modell zu senden, zu einer hohen Arbeitsspeicherauslastung auf dem Batch-Executor kommen kann (OOM-Ausnahmen).

Es gibt bestimmte Fälle, in denen dies einen hohen Durchsatz in der Bewertungsaufgabe ermöglicht. Dies ist der Fall bei Batchbereitstellungen über eine GPU-Hardware, bei denen Sie eine hohe GPU-Auslastung erreichen möchten. Ein Bewertungsskript, das diesen Ansatz nutzt, finden Sie unter Bereitstellungen mit hohem Durchsatz.

Hinweis

Wenn Sie ein generatives Modell implementieren möchten, das Dateien generiert, lernen Sie, wie Sie ein Bewertungsskript erstellen: Anpassen von Ausgaben in Batchbereitstellungen.

Erstellen der Bereitstellung

Nachdem Sie das Bewertungsskript erstellt haben, erstellen Sie eine Batchbereitstellung dafür. Gehen Sie dazu wie folgt vor:

  1. Stellen Sie sicher, dass Sie einen Computecluster erstellt haben, in dem Sie die Bereitstellung erstellen können. Verwenden Sie in diesem Beispiel einen Computecluster namens gpu-cluster. Obwohl nicht erforderlich, beschleunigt die Verwendung von GPUs die Verarbeitung.

  2. Geben Sie an, in welcher Umgebung die Bereitstellung ausgeführt werden soll. In diesem Beispiel wird das Modell in TensorFlow ausgeführt. Azure Machine Learning verfügt bereits über eine Umgebung, in der die erforderliche Software installiert ist. Somit können Sie diese Umgebung wiederverwenden. Sie müssen eine Reihe von Abhängigkeiten in einer Datei namens conda.yml hinzufügen.

    Die Umgebungsdefinition wird in die Bereitstellungsdatei aufgenommen.

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

  3. Erstellen Sie die Bereitstellung.

    Um eine neue Bereitstellung unter dem erstellten Endpunkt zu erstellen, erstellen Sie eine YAML-Konfiguration wie im folgenden Beispiel. Weitere Eigenschaften finden Sie im vollständigen YAML-Schema des Batchendpunkts.

    $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

    Erstellen Sie die Bereitstellung mit dem folgenden Befehl:

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

  4. Sie können zwar eine bestimmte Bereitstellung innerhalb eines Endpunkts aufrufen, in der Regel rufen Sie jedoch den Endpunkt selbst auf und überlassen diesem die Entscheidung, welche Bereitstellung verwendet werden soll. Eine derartige Bereitstellung wird als Standard-Bereitstellung bezeichnet.

    Mithilfe dieses Ansatzes können Sie die Standardbereitstellung und das Modell für die Bereitstellung ändern, ohne Ihren Vertrag mit dem Benutzer, der den Endpunkt aufruft, ändern zu müssen. Verwenden Sie den folgenden Code, um die Standardbereitstellung zu ändern:

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

Ihr Batchendpunkt kann verwendet werden.

Testen der Bereitstellung

Verwenden Sie zum Testen des Endpunkts eine Stichprobe von 1.000 Bildern aus dem ursprünglichen ImageNet-Dataset. Batchendpunkte können nur Daten verarbeiten, die sich in der Cloud befinden und über den Azure Machine Learning-Arbeitsbereich zugänglich sind. Laden Sie ihn in einen Azure Machine Learning-Datenspeicher hoch. Erstellen Sie eine Datenressource, die zum Aufrufen des Endpunkts für die Bewertung verwendet werden kann.

Hinweis

Batchendpunkte akzeptieren Daten, die an mehreren Speicherorttypen platziert werden können.

  1. Laden Sie die zugehörigen Beispieldaten herunter:

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

    Hinweis

    Wenn Sie wget nicht lokal installiert haben, installieren Sie es, oder verwenden Sie einen Browser, um die ZIP-Datei abzurufen.

  2. Erstellen Sie das Datenobjekt aus den heruntergeladenen Daten.

    1. Erstellen Sie eine Datenobjektdefinition in einer YAML-Datei namens 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. Erstellen Sie dann das Datenobjekt.

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

  3. Wenn die Daten hochgeladen worden und für die Verwendung bereit sind, rufen Sie den Endpunkt auf:

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

    Hinweis

    Wenn das Hilfsprogramm jq nicht installiert ist, lesen Sie Herunterladen von jq.

Tipp

Sie geben den Bereitstellungsnamen nicht im Aufrufvorgang an. Dies liegt daran, dass der Endpunkt den Auftrag automatisch an die Standardbereitstellung weiterleitet. Da der Endpunkt nur über eine Bereitstellung verfügt, ist dies der Standardwert. Sie können eine bestimmte Bereitstellung als Ziel angeben, indem Sie das Argument/den Parameter deployment_nameangeben.

  1. Sobald der Befehl zurückgegeben wird, wird ein Batchauftrag gestartet. Sie können den Status des Auftrags überwachen, bis er abgeschlossen ist.

    az ml job show -n $JOB_NAME --web

  2. Nachdem die Bereitstellung abgeschlossen ist, laden Sie die Vorhersagen herunter.

    Verwenden Sie den folgenden Befehl, um die Vorhersagen herunterzuladen:

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

  3. Die Vorhersagen sehen wie die folgende Ausgabe aus. Die Vorhersagen werden zur Erleichterung des Lesers mit Bezeichnungen kombiniert. Weitere Informationen dazu, wie Sie diesen Effekt erreichen, finden Sie im zugehörigen Notebook.

    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
    datei class Wahrscheinlichkeiten label
    n02088094_Afghan_hound.JPEG 161 0.994745 Afghan hound
    n02088238_basset 162 0.999397 basset
    n02088364_beagle.JPEG 165 0.366914 bluetick
    n02088466_bloodhound.JPEG 164 0.926464 bloodhound
    ... ... ... ...

Bereitstellungen mit hohem Durchsatz

Wie bereits erwähnt, verarbeitet die Bereitstellung nur jeweils ein Bild, auch wenn die Batchbereitstellung einen Batch von Bildern bereitstellt. In den meisten Fällen ist dieser Ansatz der beste. Er vereinfacht die Ausführung der Modelle und vermeidet mögliche Probleme aufgrund unzureichenden Speichers. In bestimmten anderen Fällen kann es jedoch sinnvoll sein, die zugrunde liegende Hardware so weit wie möglich auszulasten. Dies ist z. B. bei GPUs der Fall.

In diesen Fällen ist es sinnvoll, Rückschlüsse auf den gesamten Batch von Daten zu ziehen. Dieser Ansatz bedeutet, dass der gesamte Satz von Bildern in den Arbeitsspeicher geladen und direkt an das Modell gesendet wird. Im folgenden Beispiel wird TensorFlow verwendet, um den Batch von Bildern gleichzeitig zu lesen und zu bewerten. Für die Vorverarbeitung von Daten werden auch TensorFlow-Vorgänge verwendet. Die gesamte Pipeline wird auf demselben verwendeten Gerät (CPU/GPU) verarbeitet.

Warnung

Einige Modelle haben eine nicht lineare Beziehung zur Größe der Eingaben in Bezug auf den Speicherverbrauch. Um Ausnahmen wegen ungenügenden Arbeitsspeichers zu vermeiden, erstellen Sie den Batch erneut (wie in diesem Beispiel), oder verringern Sie die Größe der von der Batchbereitstellung erstellten Batches.

  1. Erstellen Sie das Bewertungsskript 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"]
    )
    • Dieses Skript erstellt ein Tensor-Dataset aus dem Minibatch, der von der Batchbereitstellung gesendet wird. Dieses Dataset wird vorverarbeitet, um die erwarteten Tensoren für das Modell abzurufen, indem der map-Vorgang mit der Funktion decode_img verwendet wird.
    • Das Dataset wird erneut als Batch (16) zusammengefasst, um die Daten an das Modell zu senden. Verwenden Sie diesen Parameter, um zu steuern, wie viele Informationen Sie gleichzeitig in den Arbeitsspeicher laden und an das Modell senden können. Wenn die Ausführung auf einer GPU erfolgt, müssen Sie diesen Parameter sorgfältig optimieren, um die maximale Auslastung des Grafikprozessors zu erreichen, bevor eine OOM-Ausnahme auftritt.
    • Nachdem die Vorhersagen berechnet worden sind, werden die Tensoren in numpy.ndarray konvertiert.

  2. Erstellen Sie die Bereitstellung.

    1. Um eine neue Bereitstellung unter dem erstellten Endpunkt zu erstellen, erstellen Sie eine YAML-Konfiguration wie im folgenden Beispiel. Weitere Eigenschaften finden Sie im vollständigen YAML-Schema des Batchendpunkts.
    $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. Erstellen Sie die Bereitstellung mit dem folgenden Befehl:
    az ml batch-deployment create --file deployment-by-batch.yml --endpoint-name $ENDPOINT_NAME --set-default

  3. Sie können diese neue Bereitstellung mit den zuvor gezeigten Beispieldaten verwenden. Denken Sie daran, dass Sie zum Aufrufen dieser Bereitstellung entweder den Namen der Bereitstellung in der Aufrufmethode angeben oder ihn als Standardnamen festlegen müssen.

Überlegungen zu MLflow-Modellen, die Bilder verarbeiten

MLflow-Modelle in Batchendpunkten unterstützen das Lesen von Bildern als Eingabedaten. Da MLflow-Bereitstellungen kein Bewertungsskript erfordern, sollten Sie die folgenden Überlegungen berücksichtigen, wenn Sie sie verwenden:

  • Unterstützte Bilddateien sind: .png, .jpg, .jpeg, .tiff, .bmp und .gif.
  • MLflow-Modelle sollten erwarten, dass sie ein np.ndarray als Eingabe erhalten, das den Dimensionen des Eingabebilds entspricht. Damit mehrere Bildgrößen in jedem Batch unterstützt werden, ruft der Batch Executor das MLflow-Modell einmal pro Bilddatei auf.
  • Es wird dringend empfohlen, dass MLflow-Modelle eine Signatur einschließen. Wenn sie dies tun, muss sie vom Typ TensorSpec sein. Eingaben werden umgeformt, um der Form des Tensors zu entsprechen, falls verfügbar. Wenn keine Signatur verfügbar ist, erfolgt für Tensoren des Typs np.uint8 das Rückschließen.
  • Modelle, die eine Signatur enthalten und von denen erwartet wird, dass sie variable Bildgrößen verarbeiten können, sollten eine Signatur einschließen, die dies garantieren kann. Die folgende Signatur lässt beispielsweise Batches von Bildern mit 3 Kanälen zu.
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)

Ein funktionierendes Beispiel finden Sie im Jupyter Notebook imagenet-classifier-mlflow.ipynb. Weitere Informationen zur Verwendung von MLflow-Modellen in Batchbereitstellungen finden Sie unter Verwenden von MLflow-Modellen in Batchbereitstellungen.

Nächste Schritte