Delen via

Afbeeldingsverwerking met batchmodelimplementaties

  • Artikel

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

U kunt batchmodelimplementaties gebruiken voor het verwerken van tabelgegevens, maar ook voor andere bestandstypen, zoals installatiekopieën. Deze implementaties worden ondersteund in zowel MLflow- als aangepaste modellen. In dit artikel leert u hoe u een model implementeert dat afbeeldingen classificeert op basis van de ImageNet-taxonomie.

Vereisten

  • 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. Zie Azure Machine Learning-werkruimten beheren om een werkruimte te maken.

  • Zorg ervoor dat u de volgende machtigingen hebt in de Machine Learning-werkruimte:

    • Batch-eindpunten en -implementaties maken of beheren: gebruik een eigenaar, inzender of aangepaste rol die dit toestaat Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
    • Azure Resource Manager-implementaties maken in de werkruimteresourcegroep: gebruik een eigenaar, inzender of aangepaste rol waarmee de resourcegroep waarin de werkruimte is geïmplementeerd, is toegestaan Microsoft.Resources/deployments/write .

  • Installeer de volgende software om te werken met Machine Learning:

    Voer de volgende opdracht uit om de Azure CLI en de ml extensie voor Azure Machine Learning te installeren:

    az extension add -n ml

    Implementaties van pijplijnonderdelen voor Batch-eindpunten worden geïntroduceerd in versie 2.7 van de ml extensie voor de Azure CLI. Gebruik de az extension update --name ml opdracht om de nieuwste versie op te halen.

Verbinding maken met uw werkruimte

De werkruimte is de resource op het hoogste niveau voor Machine Learning. Het biedt een centrale plek om te werken met alle artefacten die u maakt wanneer u Machine Learning gebruikt. In deze sectie maakt u verbinding met de werkruimte waar u uw implementatietaken uitvoert.

Voer in de volgende opdracht de waarden in voor uw abonnements-id, werkruimte, locatie en resourcegroep:

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

Over dit voorbeeld

In dit artikel wordt een model gebruikt dat is gebouwd met behulp van TensorFlow, samen met de RestNet-architectuur. Zie Identiteitstoewijzingen in Deep Residual Networks voor meer informatie. U kunt een voorbeeld van dit model downloaden. Het model heeft de volgende beperkingen:

  • 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. Wijzig mappen in cli/endpoints/batch/deploy-models/imagenet-classifier als u de Azure CLI of sdk/python/endpoints/batch/deploy-models/imagenet-classifier gebruikt als u de 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.

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

Maak het eindpunt dat als host fungeert voor het model:

  1. Geef de naam van het eindpunt op.

    ENDPOINT_NAME="imagenet-classifier-batch"

  2. Maak het volgende YAML-bestand om het batch-eindpunt met de naam endpoint.yml te definiëren:

    $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. U moet het model registreren. U kunt deze stap overslaan als het model dat u probeert te implementeren al is geregistreerd.

  1. Download een kopie van het model.

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

  2. Registreer het model.

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

Een scorescript maken

Maak een scorescript waarmee de installatiekopieën van de batchimplementatie kunnen worden gelezen en de scores van het model kunnen worden geretourneerd.

  • De init methode laadt het model met behulp van de keras module in tensorflow.
  • De run methode wordt uitgevoerd voor elke minibatch die de batchimplementatie biedt.
  • De run methode leest één afbeelding van het bestand tegelijk.
  • De run methode wijzigt de grootte van de afbeeldingen in de verwachte grootten voor het model.
  • De run methode schaalt de installatiekopieën opnieuw in het bereikdomein [0,1] . Dit is wat het model verwacht.
  • Het script retourneert de klassen en de waarschijnlijkheden die zijn gekoppeld aan de voorspellingen.

Deze code is de code/score-by-file/batch_driver.py bestand:

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 hoge geheugenbelasting op de batchuitvoering (OOM-uitzonderingen).

Er zijn bepaalde gevallen waarin dit een hoge doorvoer in de scoretaak mogelijk maakt. Dit is het geval voor batchimplementaties via GPU-hardware waarbij u een hoog GPU-gebruik wilt bereiken. Zie Implementaties met hoge doorvoer voor een scorescript dat gebruikmaakt van deze methode.

Notitie

Als u een generatief model wilt implementeren, waarmee bestanden worden gegenereerd, leert u hoe u een scorescript maakt: Uitvoer in batchimplementaties aanpassen.

De implementatie maken

Nadat u het scorescript hebt gemaakt, maakt u er een batchimplementatie voor. Gebruik de volgende procedure:

  1. Zorg ervoor dat u een rekencluster hebt gemaakt waar u de implementatie kunt maken. In dit voorbeeld gebruikt u een rekencluster met de naam gpu-cluster. Hoewel dit niet vereist is, versnelt het gebruik van GPU's de verwerking.

  2. Geef aan over welke omgeving de implementatie moet worden uitgevoerd. In dit voorbeeld wordt het model uitgevoerd op TensorFlow. Azure Machine Learning heeft al een omgeving waarop de vereiste software is geïnstalleerd, zodat u deze omgeving opnieuw kunt gebruiken. U moet een aantal afhankelijkheden toevoegen aan een conda.yml bestand.

    De omgevingsdefinitie is opgenomen in het implementatiebestand.

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

  3. Maak de implementatie.

    Als u een nieuwe implementatie wilt maken onder het gemaakte eindpunt, maakt u een YAML configuratie zoals in het volgende voorbeeld. Zie het YAML-schema voor het volledige batcheindpunt voor andere 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: info

    Maak de implementatie met de volgende opdracht:

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

  4. Hoewel 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 wordt de standaardimplementatie genoemd.

    Met deze methode kunt u de standaardimplementatie wijzigen en het model voor de implementatie wijzigen zonder het contract te wijzigen met de gebruiker die het eindpunt aanroept. Gebruik de volgende code om de standaardimplementatie bij te werken:

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

Uw batch-eindpunt is klaar om te worden gebruikt.

De implementatie testen

Gebruik een voorbeeld van 1000 afbeeldingen uit de oorspronkelijke ImageNet-gegevensset om het eindpunt te testen. Batch-eindpunten kunnen alleen gegevens verwerken die zich in de cloud bevinden en die toegankelijk zijn vanuit de Azure Machine Learning-werkruimte. Upload het naar een Azure Machine Learning-gegevensarchief. Maak een gegevensasset die kan worden gebruikt om het eindpunt aan te roepen voor scoren.

Notitie

Batch-eindpunten accepteren gegevens die kunnen worden geplaatst in meerdere typen locaties.

  1. Download de bijbehorende voorbeeldgegevens.

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

    Notitie

    Als u deze niet lokaal hebt wget geïnstalleerd, installeert u deze of gebruikt u een browser om het .zip-bestand op te halen.

  2. Maak de gegevensasset op basis van de gedownloade gegevens.

    1. Maak een definitie van een gegevensasset in een YAML bestand met de naam 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. Maak de gegevensasset.

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

  3. Wanneer de gegevens zijn geüpload en klaar zijn om te worden gebruikt, roept u het eindpunt aan.

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

    Notitie

    Als het hulpprogramma jq niet is geïnstalleerd, raadpleegt u Jq downloaden.

Tip

U geeft de implementatienaam in de aanroepbewerking niet aan. Dat komt doordat het eindpunt de taak automatisch doorstuurt naar de standaardimplementatie. Omdat het eindpunt slechts één implementatie heeft, is dat de standaardinstelling. U kunt een specifieke implementatie instellen door het argument/de parameter deployment_nameaan te geven.

  1. Een batchtaak wordt gestart zodra de opdracht wordt geretourneerd. U kunt de status van de taak controleren totdat deze is voltooid.

    az ml job show -n $JOB_NAME --web

  2. Nadat de implementatie is voltooid, downloadt u de voorspellingen.

    Gebruik de volgende opdracht om de voorspellingen te downloaden:

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

  3. De voorspellingen zien eruit als de volgende uitvoer. De voorspellingen worden gecombineerd met de labels voor het gemak van de lezer. Zie het bijbehorende notebook voor meer informatie over hoe u dit effect 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])
score
    bestand class Waarschijnlijkheid label
    n02088094_Afghan_hound. JPEG 161 0.994745 Afghaanse windhond
    n02088238_basset 162 0.999397 Basset
    n02088364_beagle. JPEG 165 0.366914 bluetick
    n02088466_bloodhound. JPEG 164 0.926464 bloedhond
    ... ... ... ...

Implementaties met hoge doorvoer

Zoals eerder vermeld, verwerkt de implementatie één installatiekopieën per keer, zelfs wanneer de batchimplementatie een batch ervan levert. In de meeste gevallen is deze aanpak het beste. Het vereenvoudigt hoe de modellen worden uitgevoerd en voorkomt mogelijke problemen met onvoldoende geheugen. In bepaalde andere gevallen wilt u de onderliggende hardware echter zo veel mogelijk verzadiging geven. Dit is bijvoorbeeld de case GPU's.

In deze gevallen wilt u mogelijk deductie uitvoeren voor de volledige batch met gegevens. Deze benadering impliceert dat de hele set afbeeldingen in het geheugen wordt geladen en deze rechtstreeks naar het model wordt verzonden. 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. De hele pijplijn vindt plaats 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. Om onvoldoende geheugenuitzondering te voorkomen, batcht u opnieuw (zoals in dit voorbeeld is gedaan) of verkleint u de grootte van de batches die door de batchimplementatie zijn gemaakt.

  1. Maak de scorescriptcode /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"]
    )
    • Met dit script wordt een tensor-gegevensset samengesteld uit 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 map bewerking met de functie decode_img.
    • De gegevensset wordt opnieuw gebatcheerd (16) om de gegevens naar het model te verzenden. Gebruik deze parameter om te bepalen hoeveel informatie u in het geheugen kunt laden en tegelijk naar het model kunt verzenden. Als u 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.
    • Nadat voorspellingen zijn berekend, worden de tensors geconverteerd naar numpy.ndarray.

  2. Maak de implementatie.

    1. Als u een nieuwe implementatie wilt maken onder het gemaakte eindpunt, maakt u een YAML configuratie zoals in het volgende voorbeeld. Zie het YAML-schema voor het volledige batcheindpunt voor andere 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: info
    1. Maak de implementatie met de volgende opdracht:
    az ml batch-deployment create --file deployment-by-batch.yml --endpoint-name $ENDPOINT_NAME --set-default

  3. U kunt deze nieuwe implementatie gebruiken met de voorbeeldgegevens die eerder worden weergegeven. Als u deze implementatie wilt aanroepen, geeft u de naam van de implementatie aan in de aanroepmethode of stelt u deze in als de standaardinstelling.

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 zijn: .png, .jpg, .jpeg, .tiff, .bmp en .gif.
  • MLflow-modellen verwachten een np.ndarray als 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 sterk aangemoedigd om een handtekening op te nemen. Als dat het gebeurt, moet het 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 type np.uint8 afgeleid.
  • Voor modellen die een handtekening bevatten en naar verwachting variabele grootte van afbeeldingen moeten verwerken, moet u een handtekening opnemen die deze kan garanderen. In het volgende voorbeeld van een handtekening zijn 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. Zie MLflow-modellen gebruiken in batchimplementaties voor meer informatie over het gebruik van MLflow-modellen in batchimplementaties.

Volgende stappen