Afbeeldingsverwerking met batchmodelimplementaties
VAN TOEPASSING OP:
Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)
Batchmodelimplementaties kunnen worden gebruikt voor het verwerken van tabelgegevens, maar ook voor elk ander bestandstype, zoals installatiekopieën. Deze implementaties worden ondersteund in zowel MLflow- als aangepaste modellen. In deze zelfstudie leert u hoe u een model implementeert dat afbeeldingen classificeert op basis van de ImageNet-taxonomie.
Over dit voorbeeld
Het model waarmee we gaan werken, is gebouwd met Behulp van TensorFlow, samen met de RestNet-architectuur (Identiteitstoewijzingen in Deep Residual Networks). Hier kunt u een voorbeeld van dit model downloaden. Het model heeft de volgende beperkingen die belangrijk zijn om rekening te houden met implementatie:
- Het werkt met afbeeldingen van grootte 244x244 (tensors van
(224, 224, 3)). - Hiervoor moeten invoerwaarden worden geschaald naar het bereik
[0,1].
De informatie in dit artikel is gebaseerd op codevoorbeelden in de opslagplaats azureml-examples . Als u de opdrachten lokaal wilt uitvoeren zonder YAML en andere bestanden te hoeven kopiëren/plakken, kloont u de opslagplaats en wijzigt u vervolgens mappen in de cli/endpoints/batch/deploy-models/imagenet-classifier map als u de Azure CLI gebruikt of sdk/python/endpoints/batch/deploy-models/imagenet-classifier als u onze SDK voor Python gebruikt.
git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli/endpoints/batch/deploy-models/imagenet-classifier
Volgen in Jupyter Notebooks
U kunt dit voorbeeld volgen in een Jupyter Notebook. Open in de gekloonde opslagplaats het notebook: imagenet-classifier-batch.ipynb.
Vereisten
Voordat u de stappen in dit artikel volgt, moet u ervoor zorgen dat u over de volgende vereisten beschikt:
Een Azure-abonnement. Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint. Probeer de gratis of betaalde versie van Azure Machine Learning.
Een Azure Machine Learning-werkruimte. Als u nog geen werkruimte hebt, gebruikt u de stappen in het artikel Azure Machine Learning-werkruimten beheren om er een te maken.
Zorg ervoor dat u over de volgende machtigingen in de werkruimte beschikt:
Batch-eindpunten en -implementaties maken of beheren: gebruik een eigenaar, inzender of aangepaste rol die dit toestaat
Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.ARM-implementaties maken in de resourcegroep van de werkruimte: gebruik een eigenaar, inzender of aangepaste rol die het mogelijk maakt
Microsoft.Resources/deployments/writein de resourcegroep waarin de werkruimte wordt geïmplementeerd.
U moet de volgende software installeren om te kunnen werken met Azure Machine Learning:
De Azure CLI en de
mlextensie voor Azure Machine Learning.az extension add -n mlNotitie
Implementaties van pijplijnonderdelen voor Batch-eindpunten zijn geïntroduceerd in versie 2.7 van de
mlextensie voor Azure CLI. Gebruikaz extension update --name mldeze om de laatste versie ervan op te halen.
Verbinding maken met uw werkruimte
De werkruimte is de resource op het hoogste niveau voor Azure Machine Learning en biedt een gecentraliseerde werkplek met alle artefacten die u maakt in Azure Machine Learning. In deze sectie maken we verbinding met de werkruimte waarin u implementatietaken uitvoert.
Geef de waarden voor uw abonnements-id, werkruimte, locatie en resourcegroep door in de volgende code:
az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>
Afbeeldingsclassificatie met batchimplementaties
In dit voorbeeld leert u hoe u een Deep Learning-model implementeert dat een bepaalde afbeelding kan classificeren op basis van de taxonomie van ImageNet.
Het eindpunt maken
Eerst gaan we het eindpunt maken dat als host fungeert voor het model:
Bepaal de naam van het eindpunt:
ENDPOINT_NAME="imagenet-classifier-batch"
Het volgende YAML-bestand definieert een batch-eindpunt:
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
Voer de volgende code uit om het eindpunt te maken.
az ml batch-endpoint create --file endpoint.yml --name $ENDPOINT_NAME
Het model registreren
Modelimplementaties kunnen alleen geregistreerde modellen implementeren, dus moeten we deze registreren. U kunt deze stap overslaan als het model dat u probeert te implementeren al is geregistreerd.
Een kopie van het model downloaden:
Registreer het model:
Een scorescript maken
We moeten een scorescript maken waarmee de installatiekopieën van de batchimplementatie kunnen worden gelezen en de scores van het model kunnen worden geretourneerd. Het volgende script:
- Geeft een
initfunctie aan die het model laadt met behulp vankerasmodule intensorflow. - Geeft een
runfunctie aan die wordt uitgevoerd voor elke minibatch die de batch-implementatie biedt. - De
runfunctie heeft één afbeelding van het bestand tegelijk gelezen - De
runmethode wijzigt de grootte van de afbeeldingen in de verwachte grootten voor het model. - De
runmethode schaalt de installatiekopieën opnieuw in het bereikdomein[0,1]. Dit is wat het model verwacht. - Hiermee worden de klassen en de waarschijnlijkheden geretourneerd die aan de voorspellingen zijn gekoppeld.
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)
Tip
Hoewel installatiekopieën worden geleverd in minibatches door de implementatie, verwerkt dit scorescript één installatiekopieën tegelijk. Dit is een veelvoorkomend patroon omdat het laden van de hele batch en het tegelijkertijd naar het model verzendt, kan leiden tot een hoge geheugenbelasting op de batchuitvoering (OOM-exeptions). Er zijn echter bepaalde gevallen waarin dit een hoge doorvoer in de scoretaak mogelijk maakt. Dit is het geval voor batchimplementaties via een GPU-hardware waarbij we een hoog GPU-gebruik willen bereiken. Zie Implementaties met hoge doorvoer voor een voorbeeld van een scorescript dat hiervan gebruikmaakt.
Notitie
Als u een generatief model probeert te implementeren (een model dat bestanden genereert), leest u hoe u een scorescript maakt, zoals wordt uitgelegd bij de implementatie van modellen die meerdere bestanden produceren.
De implementatie maken
Een van de scorescripts wordt gemaakt. Het is tijd om er een batchimplementatie voor te maken. Volg de volgende stappen om deze te maken:
Zorg ervoor dat u een rekencluster hebt gemaakt waar we de implementatie kunnen maken. In dit voorbeeld gebruiken we een rekencluster met de naam
gpu-cluster. Hoewel dit niet vereist is, gebruiken we GPU's om de verwerking te versnellen.We moeten aangeven over welke omgeving we de implementatie gaan uitvoeren. In ons geval wordt ons model uitgevoerd op
TensorFlow. Azure Machine Learning heeft al een omgeving waarop de vereiste software is geïnstalleerd, zodat we deze omgeving opnieuw kunnen gebruiken. We gaan gewoon een aantal afhankelijkheden toevoegen aan eenconda.ymlbestand.Nu gaan we de implementatie maken.
Als u een nieuwe implementatie wilt maken onder het gemaakte eindpunt, maakt u een
YAMLconfiguratie zoals hieronder. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.$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: infoMaak vervolgens de implementatie met de volgende opdracht:
az ml batch-deployment create --file deployment-by-file.yml --endpoint-name $ENDPOINT_NAME --set-defaultHoewel u een specifieke implementatie binnen een eindpunt kunt aanroepen, wilt u meestal het eindpunt zelf aanroepen en het eindpunt laten bepalen welke implementatie moet worden gebruikt. Deze implementatie heet de standaardimplementatie. Dit biedt u de mogelijkheid om de standaardimplementatie te wijzigen en daarom het model te wijzigen dat de implementatie bedient, zonder het contract te wijzigen met de gebruiker die het eindpunt aanroept. Gebruik de volgende instructie om de standaardimplementatie bij te werken:
az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAMEOp dit moment is ons batcheindpunt gereed om te worden gebruikt.
De implementatie testen
Voor het testen van ons eindpunt gebruiken we een voorbeeld van 1000 afbeeldingen uit de oorspronkelijke ImageNet-gegevensset. Batch-eindpunten kunnen alleen gegevens verwerken die zich in de cloud bevinden en die toegankelijk zijn vanuit de Azure Machine Learning-werkruimte. In dit voorbeeld gaan we het uploaden naar een Azure Machine Learning-gegevensarchief. We gaan met name een gegevensasset maken die kan worden gebruikt om het eindpunt aan te roepen voor scoren. U ziet echter dat batcheindpunten gegevens accepteren die op meerdere typen locaties kunnen worden geplaatst.
We gaan de bijbehorende voorbeeldgegevens downloaden:
Nu gaan we de gegevensasset maken van de zojuist gedownloade gegevens
Een gegevensassetdefinitie maken 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: dataMaak vervolgens de gegevensasset:
az ml data create -f imagenet-sample-unlabeled.ymlNu de gegevens zijn geüpload en klaar zijn om te worden gebruikt, gaan we het eindpunt aanroepen:
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input azureml:imagenet-sample-unlabeled@latest --query name -o tsv)Notitie
Het hulpprogramma
jqis mogelijk niet geïnstalleerd op elke installatie. In deze koppeling vindt u instructies.Tip
U ziet dat de implementatienaam in de aanroepbewerking niet wordt aangegeven. Dat komt doordat het eindpunt de taak automatisch doorstuurt naar de standaardimplementatie. Omdat ons eindpunt slechts één implementatie heeft, is dat de standaardimplementatie. U kunt een specifieke implementatie instellen door het argument/de parameter
deployment_nameaan te geven.Er wordt een batchtaak gestart zodra de opdracht wordt geretourneerd. U kunt de status van de taak controleren totdat deze is voltooid:
Zodra de implementatie is voltooid, kunnen we de voorspellingen downloaden:
De uitvoervoorspellingen zien er als volgt uit. U ziet dat de voorspellingen zijn gecombineerd met de labels voor het gemak van de lezer. Zie het bijbehorende notitieblok voor meer informatie over hoe u dit kunt bereiken.
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]) scorebestand class Waarschijnlijkheid label n02088094_Afghan_hound. JPEG 161 0.994745 Afghaanse hond n02088238_basset 162 0.999397 Basset n02088364_beagle. JPEG 165 0.366914 bluetick n02088466_bloodhound. JPEG 164 0.926464 Bloodhound ... ... ... ...
Implementaties met hoge doorvoer
Zoals eerder vermeld, verwerkt de implementatie die we zojuist zojuist hebben gemaakt één installatiekopieën, zelfs wanneer de batchimplementatie een batch ervan levert. In de meeste gevallen is dit de beste aanpak, omdat het vereenvoudigt hoe de modellen worden uitgevoerd en mogelijke problemen met onvoldoende geheugen worden voorkomen. In bepaalde andere kunnen we echter zoveel mogelijk het gebruik van de onderliggende hardware verzadiging geven. Dit is bijvoorbeeld het geval gpu's.
In deze gevallen willen we mogelijk deductie uitvoeren voor de volledige batch met gegevens. Dat betekent dat u de volledige set afbeeldingen in het geheugen laadt en deze rechtstreeks naar het model verzendt. In het volgende voorbeeld wordt gebruikgemaakt TensorFlow van het lezen van batch afbeeldingen en het beoordelen ervan allemaal tegelijk. Het maakt ook gebruik TensorFlow van ops om gegevens vooraf te verwerken, zodat de volledige pijplijn plaatsvindt op hetzelfde apparaat dat wordt gebruikt (CPU/GPU).
Waarschuwing
Sommige modellen hebben een niet-lineaire relatie met de grootte van de invoer in termen van het geheugenverbruik. Batch opnieuw (zoals in dit voorbeeld is gedaan) of verklein de grootte van de batches die door de batch-implementatie zijn gemaakt om onvoldoende geheugenuitzondering te voorkomen.
Het scorescript maken:
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"] )Tip
- U ziet dat dit script een tensor-gegevensset maakt van de minibatch die door de batchimplementatie wordt verzonden. Deze gegevensset wordt vooraf verwerkt om de verwachte tensors voor het model te verkrijgen met behulp van de
mapbewerking met de functiedecode_img. - De gegevensset wordt opnieuw gebatcheerd (16) verzendt de gegevens naar het model. Gebruik deze parameter om te bepalen hoeveel informatie u in het geheugen kunt laden en tegelijk naar het model kunt verzenden. Als u op een GPU uitvoert, moet u deze parameter zorgvuldig afstemmen om het maximale gebruik van de GPU te bereiken net voordat u een OOM-uitzondering krijgt.
- Zodra voorspellingen zijn berekend, worden de tensors geconverteerd naar
numpy.ndarray.
- U ziet dat dit script een tensor-gegevensset maakt van de minibatch die door de batchimplementatie wordt verzonden. Deze gegevensset wordt vooraf verwerkt om de verwachte tensors voor het model te verkrijgen met behulp van de
Nu gaan we de implementatie maken.
Als u een nieuwe implementatie wilt maken onder het gemaakte eindpunt, maakt u een
YAMLconfiguratie zoals hieronder. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.$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: infoMaak vervolgens de implementatie met de volgende opdracht:
az ml batch-deployment create --file deployment-by-batch.yml --endpoint-name $ENDPOINT_NAME --set-defaultU kunt deze nieuwe implementatie gebruiken met de voorbeeldgegevens die eerder worden weergegeven. Als u deze implementatie wilt aanroepen, moet u de naam van de implementatie in de aanroepmethode aangeven of deze als standaard instellen.
Overwegingen voor MLflow-modellen die afbeeldingen verwerken
MLflow-modellen in Batch-eindpunten ondersteunen het lezen van afbeeldingen als invoergegevens. Aangezien MLflow-implementaties geen scorescript vereisen, moet u rekening houden met de volgende overwegingen bij het gebruik ervan:
- Ondersteunde afbeeldingsbestanden omvatten:
.png,.jpg,.jpeg,.tiffen.gif.bmp. - MLflow-modellen verwachten een
np.ndarrayals invoer te ontvangen die overeenkomt met de afmetingen van de invoerafbeelding. Om meerdere afbeeldingsgrootten in elke batch te ondersteunen, roept de batchuitvoering het MLflow-model eenmaal per afbeeldingsbestand aan. - MLflow-modellen worden ten zeerste aangemoedigd om een handtekening op te nemen en als ze dit doen, moeten ze van het type
TensorSpeczijn. Invoer wordt aangepast aan de shape van tensor, indien beschikbaar. Als er geen handtekening beschikbaar is, worden de tensors van het typenp.uint8afgeleid. - Voor modellen die een handtekening bevatten en naar verwachting variabele grootte van afbeeldingen moeten verwerken, moet u vervolgens een handtekening opnemen die dit kan garanderen. In het volgende voorbeeld van een handtekening worden bijvoorbeeld batches van drie gekanaalde afbeeldingen toegestaan.
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)
U vindt een werkend voorbeeld in de Jupyter notebook imagenet-classifier-mlflow.ipynb. Lees MLflow-modellen gebruiken in batchimplementaties voor meer informatie over het gebruik van MLflow-modellen in batchimplementaties.