Bildverarbeitung mit Batchmodellimplementierungen
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 keinen 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 Sieaz 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.
Herunterladen einer Kopie des Modells:
wget https://azuremlexampledata.blob.core.windows.net/data/imagenet/model.zip unzip model.zip -d .
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 Modulskeras
intensorflow
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:
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.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 einerconda.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
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
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
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.
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
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
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_name
angeben.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
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 ./
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.
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 Funktiondecode_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.ndarray
konvertiert.
- 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
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
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 Typsnp.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
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für