Share via

Bildverarbeitung mit Batchmodellimplementierungen

  • Artikel

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

Batchmodellimplementierungen können für die Verarbeitung von Tabellendaten verwendet werden, 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 Tutorial erfahren Sie, wie Sie ein Modell bereitstellen, das Bilder gemäß der ImageNet-Taxonomie klassifiziert.

Informationen zu diesem Beispiel

Das Modell, mit dem wir arbeiten, wurde mit TensorFlow in Verbindung mit der RestNet-Architektur erstellt (Identity Mappings in Deep Residual Networks (Identitätszuordnungen in Deep Residual Networks)). Ein Beispiel dieses Modells kann hier heruntergeladen werden. Das Modell weist die folgenden Einschränkungen auf, die bei der Bereitstellung beachtet werden müssen:

  • 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. Um die Befehle lokal auszuführen, ohne YAML und andere Dateien kopieren und einfügen zu müssen, klonen Sie das Repository, und wechseln Sie dann zum Verzeichnis cli/endpoints/batch/deploy-models/imagenet-classifier, wenn Sie die Azure CLI verwenden, oder zu sdk/python/endpoints/batch/deploy-models/imagenet-classifier, wenn Sie unser 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.

Voraussetzungen

Stellen Sie vor dem Ausführen der Schritte in diesem Artikel sicher, dass Sie über die folgenden erforderlichen Komponenten verfügen:

  • 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. Wenn Sie keins haben, führen Sie die Schritte im Artikel Verwalten von Azure Machine Learning-Arbeitsbereichen aus, um einen Arbeitsbereich zu erstellen.

  • Stellen Sie sicher, dass Sie im Arbeitsbereich über die folgenden Berechtigungen 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 ARM-Bereitstellungen in der Arbeitsbereichsressourcengruppe: Verwenden Sie die Rolle für Besitzer oder Mitwirkende oder eine benutzerdefinierte Rolle, die Microsoft.Resources/deployments/write in der Ressourcengruppe zulässt, in der der Arbeitsbereich bereitgestellt wird.

  • Für die Arbeit mit Azure Machine Learning müssen Sie die folgende Software installieren:

    Die Azure CLI und die ml-Erweiterung für Azure Machine Learning.

    az extension add -n ml

    Hinweis

    Bereitstellungen der Pipelinekomponenten für Batchendpunkte wurden in Version 2.7 der Erweiterung ml für die Azure CLI eingeführt. Verwenden Sie az extension update --name ml, um die letzte Version davon zu erhalten.

Herstellen einer Verbindung mit Ihrem Arbeitsbereich

Der Arbeitsbereich ist die Ressource der obersten Ebene für Azure Machine Learning und ein zentraler Ort für die Arbeit mit allen Artefakten, die Sie während der Nutzung von Azure Machine Learning erstellen. In diesem Abschnitt stellen wir eine Verbindung mit dem Arbeitsbereich her, in dem Sie die Bereitstellung vornehmen werden.

Übergeben Sie die Werte für Ihre Abonnement-ID, Ihren Arbeitsbereich, Ihren Standort und Ihre Ressourcengruppe im folgenden Code:

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

Bildklassifizierung mit Batchbereitstellungen

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

Erstellen des Endpunkts

Zunächst erstellen wir den Endpunkt, der das Modell hosten soll:

Entscheiden Sie sich für den Namen des Endpunkts:

ENDPOINT_NAME="imagenet-classifier-batch"

Die folgende YAML-Datei definiert einen Batchendpunkt:

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

Führen Sie den folgenden Code aus, um den Endpunkt zu erstellen.

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

Registrieren des Modells

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

  1. Herunterladen einer Kopie des Modells:

    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 eines Bewertungsskripts

Wir müssen ein Bewertungsskript erstellen, das die von der Batchbereitstellung bereitgestellten Bilder lesen und die Bewertungen des Modells zurückgeben kann. Für das folgende Skript gilt:

  • Gibt eine init-Funktion an, die das Modell mithilfe des Moduls keras in tensorflow lädt.
  • Gibt eine run-Funktion an, die für jeden Minibatch ausgeführt wird, den die Batchbereitstellung bereitstellt.
  • Die run-Funktion 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.
  • Es gibt die Klassen und die Wahrscheinlichkeiten im Zusammenhang mit den Vorhersagen zurück.

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, da 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 jedoch bestimmte Fälle, in denen dies einen hohen Durchsatz in der Bewertungsaufgabe ermöglicht. Dies ist beispielsweise der Fall bei Batchbereitstellungen über eine GPU-Hardware, bei denen wir eine hohe GPU-Auslastung erreichen möchten. Ein Beispiel für ein Bewertungsskript, das dies nutzt, finden Sie unter Bereitstellungen mit hohem Durchsatz.

Hinweis

Wenn Sie versuchen, ein generatives Modell (eines, das Dateien generiert) bereitzustellen, lesen Sie unter Deployment of models that produces multiple files (Bereitstellung von Modellen, die mehrere Dateien erzeugen) nach, wie Sie ein Bewertungsskript erstellen.

Erstellen der Bereitstellung

Nachdem das Bewertungsskript erstellt wurde, ist es an der Zeit, dafür eine Batchbereitstellung zu erstellen. Führen Sie für die Erstellung die folgenden Schritte aus:

  1. Stellen Sie sicher, dass Sie einen Computecluster erstellt haben, in dem wir die Bereitstellung erstellen können. In diesem Beispiel verwenden wir einen Computecluster namens gpu-cluster. Obwohl dies nicht erforderlich ist, verwenden wir GPUs, um die Verarbeitung zu beschleunigen.

  2. Wir müssen angeben, in welcher Umgebung wir die Bereitstellung ausführen werden. In unserem Fall wird unser Modell auf TensorFlow ausgeführt. Azure Machine Learning verfügt bereits über eine Umgebung, in der die erforderliche Software installiert ist. Somit können wir diese Umgebung erneut nutzen. Wir werden nur einige Abhängigkeiten in einer conda.yml-Datei hinzufügen.

    Die Umgebungsdefinition wird in die Bereitstellungsdatei eingeschlossen.

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

  3. Erstellen wir nun die Bereitstellung.

    Um eine neue Bereitstellung unter dem erstellten Endpunkt zu erstellen, erstellen Sie eine YAML-Konfiguration wie die folgende. Sie können das vollständige YAML-Schema des Batchendpunkts auf zusätzliche Eigenschaften überprüfen.

    $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 dann die Bereitstellung mit dem folgenden Befehl:

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

  4. Obwohl Sie eine bestimmte Bereitstellung innerhalb eines Endpunkts aufrufen können, rufen Sie in der Regel den Endpunkt selbst auf und lassen den Endpunkt entscheiden, welche Bereitstellung verwendet werden soll. Eine derartige Bereitstellung wird als "Standard"-Bereitstellung bezeichnet. Dadurch erhalten Sie die Möglichkeit, die Standardbereitstellung und somit das Modell für die Bereitstellung zu ändern, ohne den Vertrag mit dem Benutzer ändern zu müssen, der den Endpunkt aufruft. Verwenden Sie die folgende Anweisung, um die Standardbereitstellung zu aktualisieren:

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

  5. An diesem Punkt ist unser Batchendpunkt zur Verwendung bereit.

Durchtesten der Bereitstellung

Zum Testen unseres Endpunkts verwenden wir eine Stichprobe von 1000 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. In diesem Beispiel laden wir sie in einen Azure Machine Learning-Datenspeicher hoch. Insbesondere erstellen wir eine Datenressource, die zum Aufrufen des Endpunkts für die Bewertung verwendet werden kann. Beachten Sie jedoch, dass Batchendpunkte Daten akzeptieren, die an mehreren verschiedenen Speicherorten platziert werden können.

  1. Jetzt laden wir die zugehörigen Beispieldaten herunter:

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

  2. Nun erstellen wir die Datenressource aus den Daten, die gerade heruntergeladen wurden.

    Erstellen Sie eine Datenressourcendefinition in 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

    Erstellen Sie dann die Datenressource:

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

  3. Nachdem die Daten hochgeladen und für die Verwendung bereit sind, rufen wir den Endpunkt auf:

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

    Hinweis

    Das Hilfsprogramm jq wird möglicherweise nicht auf jeder Installation installiert. Anweisungen erhalten Sie unter diesem Link.

    Tipp

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

  4. Ein Batchauftrag wird gestartet, sobald der Befehl zurückgegeben wird. Sie können den Status des Auftrags überwachen, bis er abgeschlossen ist:

    az ml job show -n $JOB_NAME --web

  5. Nachdem die Bereitstellung abgeschlossen wurde, können wir die Vorhersagen herunterladen:

    Verwenden Sie den folgenden Befehl, um die Vorhersagen herunterzuladen:

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

  6. Die Ausgabevorhersagen sehen dann folgendermaßen aus. Beachten Sie, dass zum besseren Verständnis für den Leser die Vorhersagen mit den Bezeichnungen kombiniert wurden. Weitere Informationen hierzu 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
    file 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 gerade erstellte Bereitstellung nur jeweils ein Bild, auch wenn die Batchbereitstellung einen Batch von Bildern bereitstellt. In den meisten Fällen ist dies der beste Ansatz, da er die Ausführung der Modelle vereinfacht und alle möglichen Probleme durch ungenügenden Arbeitsspeicher vermieden werden. In bestimmten anderen Fällen möchten wir jedoch die maximale Auslastung der zugrunde liegenden Hardware so weit wie möglich erreichen. Dies ist zum Beispiel bei GPUs der Fall.

In diesen Fällen möchten wir möglicherweise Rückschlüsse auf den gesamten Datenbatch ausführen. Dies 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. Zudem werden TensorFlow-Vorgänge verwendet, um alle Datenvorverarbeitungen durchzuführen, sodass die gesamte Pipeline auf demselben verwendeten Gerät ausgeführt wird (CPU/GPU).

Warnung

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

  1. Erstellen des Bewertungsskripts:

    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"]
    )

    Tipp

    • Beachten Sie, dass dieses Skript ein Tensor-Dataset aus dem Minibatch erstellt, 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 zusammengefasst (16), senden Sie die Daten an das Modell. 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 vorsichtig optimieren, bis Sie die maximale Auslastung der GPU erreichen, ohne eine OOM-Ausnahme zu erhalten.
    • Sobald Vorhersagen berechnet wurden, werden die Tensoren in numpy.ndarraykonvertiert.

  2. Erstellen wir nun die Bereitstellung.

    Um eine neue Bereitstellung unter dem erstellten Endpunkt zu erstellen, erstellen Sie eine YAML-Konfiguration wie die folgende. Sie können das vollständige YAML-Schema des Batchendpunkts auf zusätzliche Eigenschaften überprüfen.

    $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

    Erstellen Sie dann 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 sollten.

Ü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:

  • Zu den unterstützten Bilddateien gehören: .png, .jpg, .jpeg, .tiff, .bmp und .gif.
  • MLflow-Modelle sollten erwarten, dass sie einen np.ndarray als Eingabe erhalten, der 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.
  • Für MLflow-Modelle wird dringend empfohlen, dass sie eine Signatur enthalten, und wenn dies der Fall ist, muss sie den Typ TensorSpec aufweisen. 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.
  • Für Modelle, die eine Signatur enthalten und von denen ausgegangen wird, dass sie variable Bildgrößen verarbeiten können, sollten Sie 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